iso15118 0.1.0

// @generated by iso15118-codegen. Do not edit.
//
// Source schemas: V2G_CI_MsgBody.xsd, V2G_CI_MsgDataTypes.xsd, V2G_CI_MsgDef.xsd, V2G_CI_MsgHeader.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_MsgDef";

/// `AC_EVChargeParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACEVChargeParameter {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `EAmount` element, 1..1.
    pub e_amount: PhysicalValue,
    /// `EVMaxVoltage` element, 1..1.
    pub ev_max_voltage: PhysicalValue,
    /// `EVMaxCurrent` element, 1..1.
    pub ev_max_current: PhysicalValue,
    /// `EVMinCurrent` element, 1..1.
    pub ev_min_current: PhysicalValue,
}

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

impl ACEVChargeParameter {
    /// 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);
        // DepartureTime (0..1)
        if let Some(item) = &self.departure_time {
            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);
        }
        // EAmount (1..1)
        {
            let item = &self.e_amount;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMaxVoltage (1..1)
        {
            let item = &self.ev_max_voltage;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVMaxCurrent (1..1)
        {
            let item = &self.ev_max_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVMinCurrent (1..1)
        {
            let item = &self.ev_min_current;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ACEVChargeParameter {
    /// 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;
        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 = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            departure_time: f_0,
            e_amount: f_1.ok_or(ExiError::MissingElement)?,
            ev_max_voltage: f_2.ok_or(ExiError::MissingElement)?,
            ev_max_current: f_3.ok_or(ExiError::MissingElement)?,
            ev_min_current: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `AC_EVSEChargeParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACEVSEChargeParameter {
    /// `AC_EVSEStatus` element, 1..1.
    pub ac_evse_status: ACEVSEStatus,
    /// `EVSENominalVoltage` element, 1..1.
    pub evse_nominal_voltage: PhysicalValue,
    /// `EVSEMaxCurrent` element, 1..1.
    pub evse_max_current: PhysicalValue,
}

impl ACEVSEChargeParameter {
    /// 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 ACEVSEChargeParameter {
    /// 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);
        // AC_EVSEStatus (1..1)
        {
            let item = &self.ac_evse_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVSENominalVoltage (1..1)
        {
            let item = &self.evse_nominal_voltage;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEMaxCurrent (1..1)
        {
            let item = &self.evse_max_current;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ACEVSEChargeParameter {
    /// 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, .. } => {
                    let value = ACEVSEStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ac_evse_status: f_0.ok_or(ExiError::MissingElement)?,
            evse_nominal_voltage: f_1.ok_or(ExiError::MissingElement)?,
            evse_max_current: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `AC_EVSEStatusType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACEVSEStatus {
    /// `NotificationMaxDelay` element, 1..1.
    pub notification_max_delay: u16,
    /// `EVSENotification` element, 1..1.
    pub evse_notification: EVSENotification,
    /// `RCD` element, 1..1.
    pub rcd: bool,
}

impl ACEVSEStatus {
    /// 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 ACEVSEStatus {
    /// 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);
        // NotificationMaxDelay (1..1)
        {
            let item = &self.notification_max_delay;
            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);
        }
        // EVSENotification (1..1)
        {
            let item = &self.evse_notification;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EVSENotification::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // RCD (1..1)
        {
            let item = &self.rcd;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ACEVSEStatus {
    /// 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 = 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 = EVSENotification::from_index(d.nbit(EVSENotification::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 = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            notification_max_delay: f_0.ok_or(ExiError::MissingElement)?,
            evse_notification: f_1.ok_or(ExiError::MissingElement)?,
            rcd: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `AuthorizationReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationReq {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `GenChallenge` element, 0..1.
    pub gen_challenge: Option<Vec<u8>>,
}

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

impl AuthorizationReq {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(106), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // GenChallenge (0..1)
        if let Some(item) = &self.gen_challenge {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::exact(16))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl AuthorizationReq {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(106), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::exact(16))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { id: f_0, gen_challenge: f_1 })
    }
}

/// `AuthorizationResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: EVSEProcessing,
}

impl AuthorizationRes {
    /// 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 AuthorizationRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EVSEProcessing (1..1)
        {
            let item = &self.evse_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EVSEProcessing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl AuthorizationRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = EVSEProcessing::from_index(d.nbit(EVSEProcessing::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            evse_processing: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `BodyBaseType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BodyBase;

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

impl BodyBase {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BodyBase {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// The `choice of 35` alternatives of [`Body`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BodyChoice {
    /// `AuthorizationReq`
    AuthorizationReq(AuthorizationReq),
    /// `AuthorizationRes`
    AuthorizationRes(AuthorizationRes),
    /// `BodyElement`
    BodyElement(BodyBase),
    /// `CableCheckReq`
    CableCheckReq(CableCheckReq),
    /// `CableCheckRes`
    CableCheckRes(CableCheckRes),
    /// `CertificateInstallationReq`
    CertificateInstallationReq(CertificateInstallationReq),
    /// `CertificateInstallationRes`
    CertificateInstallationRes(CertificateInstallationRes),
    /// `CertificateUpdateReq`
    CertificateUpdateReq(CertificateUpdateReq),
    /// `CertificateUpdateRes`
    CertificateUpdateRes(CertificateUpdateRes),
    /// `ChargeParameterDiscoveryReq`
    ChargeParameterDiscoveryReq(ChargeParameterDiscoveryReq),
    /// `ChargeParameterDiscoveryRes`
    ChargeParameterDiscoveryRes(ChargeParameterDiscoveryRes),
    /// `ChargingStatusReq`
    ChargingStatusReq(ChargingStatusReq),
    /// `ChargingStatusRes`
    ChargingStatusRes(ChargingStatusRes),
    /// `CurrentDemandReq`
    CurrentDemandReq(CurrentDemandReq),
    /// `CurrentDemandRes`
    CurrentDemandRes(CurrentDemandRes),
    /// `MeteringReceiptReq`
    MeteringReceiptReq(MeteringReceiptReq),
    /// `MeteringReceiptRes`
    MeteringReceiptRes(MeteringReceiptRes),
    /// `PaymentDetailsReq`
    PaymentDetailsReq(PaymentDetailsReq),
    /// `PaymentDetailsRes`
    PaymentDetailsRes(PaymentDetailsRes),
    /// `PaymentServiceSelectionReq`
    PaymentServiceSelectionReq(PaymentServiceSelectionReq),
    /// `PaymentServiceSelectionRes`
    PaymentServiceSelectionRes(PaymentServiceSelectionRes),
    /// `PowerDeliveryReq`
    PowerDeliveryReq(PowerDeliveryReq),
    /// `PowerDeliveryRes`
    PowerDeliveryRes(PowerDeliveryRes),
    /// `PreChargeReq`
    PreChargeReq(PreChargeReq),
    /// `PreChargeRes`
    PreChargeRes(PreChargeRes),
    /// `ServiceDetailReq`
    ServiceDetailReq(ServiceDetailReq),
    /// `ServiceDetailRes`
    ServiceDetailRes(ServiceDetailRes),
    /// `ServiceDiscoveryReq`
    ServiceDiscoveryReq(ServiceDiscoveryReq),
    /// `ServiceDiscoveryRes`
    ServiceDiscoveryRes(ServiceDiscoveryRes),
    /// `SessionSetupReq`
    SessionSetupReq(SessionSetupReq),
    /// `SessionSetupRes`
    SessionSetupRes(SessionSetupRes),
    /// `SessionStopReq`
    SessionStopReq(SessionStopReq),
    /// `SessionStopRes`
    SessionStopRes(SessionStopRes),
    /// `WeldingDetectionReq`
    WeldingDetectionReq(WeldingDetectionReq),
    /// `WeldingDetectionRes`
    WeldingDetectionRes(WeldingDetectionRes),
}

impl BodyChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::AuthorizationReq(_) => "AuthorizationReq",
            Self::AuthorizationRes(_) => "AuthorizationRes",
            Self::BodyElement(_) => "BodyElement",
            Self::CableCheckReq(_) => "CableCheckReq",
            Self::CableCheckRes(_) => "CableCheckRes",
            Self::CertificateInstallationReq(_) => "CertificateInstallationReq",
            Self::CertificateInstallationRes(_) => "CertificateInstallationRes",
            Self::CertificateUpdateReq(_) => "CertificateUpdateReq",
            Self::CertificateUpdateRes(_) => "CertificateUpdateRes",
            Self::ChargeParameterDiscoveryReq(_) => "ChargeParameterDiscoveryReq",
            Self::ChargeParameterDiscoveryRes(_) => "ChargeParameterDiscoveryRes",
            Self::ChargingStatusReq(_) => "ChargingStatusReq",
            Self::ChargingStatusRes(_) => "ChargingStatusRes",
            Self::CurrentDemandReq(_) => "CurrentDemandReq",
            Self::CurrentDemandRes(_) => "CurrentDemandRes",
            Self::MeteringReceiptReq(_) => "MeteringReceiptReq",
            Self::MeteringReceiptRes(_) => "MeteringReceiptRes",
            Self::PaymentDetailsReq(_) => "PaymentDetailsReq",
            Self::PaymentDetailsRes(_) => "PaymentDetailsRes",
            Self::PaymentServiceSelectionReq(_) => "PaymentServiceSelectionReq",
            Self::PaymentServiceSelectionRes(_) => "PaymentServiceSelectionRes",
            Self::PowerDeliveryReq(_) => "PowerDeliveryReq",
            Self::PowerDeliveryRes(_) => "PowerDeliveryRes",
            Self::PreChargeReq(_) => "PreChargeReq",
            Self::PreChargeRes(_) => "PreChargeRes",
            Self::ServiceDetailReq(_) => "ServiceDetailReq",
            Self::ServiceDetailRes(_) => "ServiceDetailRes",
            Self::ServiceDiscoveryReq(_) => "ServiceDiscoveryReq",
            Self::ServiceDiscoveryRes(_) => "ServiceDiscoveryRes",
            Self::SessionSetupReq(_) => "SessionSetupReq",
            Self::SessionSetupRes(_) => "SessionSetupRes",
            Self::SessionStopReq(_) => "SessionStopReq",
            Self::SessionStopRes(_) => "SessionStopRes",
            Self::WeldingDetectionReq(_) => "WeldingDetectionReq",
            Self::WeldingDetectionRes(_) => "WeldingDetectionRes",
        }
    }
}

impl BodyChoice {
    /// The `ResponseCode`, for the branches that are responses.
    ///
    /// `None` for a request, which carries no code.
    #[must_use]
    pub const fn response_code(&self) -> Option<ResponseCode> {
        match self {
            Self::AuthorizationRes(m) => Some(m.response_code),
            Self::CableCheckRes(m) => Some(m.response_code),
            Self::CertificateInstallationRes(m) => Some(m.response_code),
            Self::CertificateUpdateRes(m) => Some(m.response_code),
            Self::ChargeParameterDiscoveryRes(m) => Some(m.response_code),
            Self::ChargingStatusRes(m) => Some(m.response_code),
            Self::CurrentDemandRes(m) => Some(m.response_code),
            Self::MeteringReceiptRes(m) => Some(m.response_code),
            Self::PaymentDetailsRes(m) => Some(m.response_code),
            Self::PaymentServiceSelectionRes(m) => Some(m.response_code),
            Self::PowerDeliveryRes(m) => Some(m.response_code),
            Self::PreChargeRes(m) => Some(m.response_code),
            Self::ServiceDetailRes(m) => Some(m.response_code),
            Self::ServiceDiscoveryRes(m) => Some(m.response_code),
            Self::SessionSetupRes(m) => Some(m.response_code),
            Self::SessionStopRes(m) => Some(m.response_code),
            Self::WeldingDetectionRes(m) => Some(m.response_code),
            _ => None,
        }
    }
}

/// `BodyType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Body {
    /// `choice of 35` element, 0..1.
    pub choice: Option<BodyChoice>,
}

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

impl Body {
    /// 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 35 (0..1)
        if let Some(item) = &self.choice {
            match item {
                BodyChoice::AuthorizationReq(value) => {
                    w.start_branch(e, 0, 0, 0)?;
                    value.encode_body(e)?;
                }
                BodyChoice::AuthorizationRes(value) => {
                    w.start_branch(e, 0, 0, 1)?;
                    value.encode_body(e)?;
                }
                BodyChoice::BodyElement(value) => {
                    w.start_branch(e, 0, 0, 2)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CableCheckReq(value) => {
                    w.start_branch(e, 0, 0, 3)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CableCheckRes(value) => {
                    w.start_branch(e, 0, 0, 4)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CertificateInstallationReq(value) => {
                    w.start_branch(e, 0, 0, 5)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CertificateInstallationRes(value) => {
                    w.start_branch(e, 0, 0, 6)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CertificateUpdateReq(value) => {
                    w.start_branch(e, 0, 0, 7)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CertificateUpdateRes(value) => {
                    w.start_branch(e, 0, 0, 8)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ChargeParameterDiscoveryReq(value) => {
                    w.start_branch(e, 0, 0, 9)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ChargeParameterDiscoveryRes(value) => {
                    w.start_branch(e, 0, 0, 10)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ChargingStatusReq(value) => {
                    w.start_branch(e, 0, 0, 11)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ChargingStatusRes(value) => {
                    w.start_branch(e, 0, 0, 12)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CurrentDemandReq(value) => {
                    w.start_branch(e, 0, 0, 13)?;
                    value.encode_body(e)?;
                }
                BodyChoice::CurrentDemandRes(value) => {
                    w.start_branch(e, 0, 0, 14)?;
                    value.encode_body(e)?;
                }
                BodyChoice::MeteringReceiptReq(value) => {
                    w.start_branch(e, 0, 0, 15)?;
                    value.encode_body(e)?;
                }
                BodyChoice::MeteringReceiptRes(value) => {
                    w.start_branch(e, 0, 0, 16)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PaymentDetailsReq(value) => {
                    w.start_branch(e, 0, 0, 17)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PaymentDetailsRes(value) => {
                    w.start_branch(e, 0, 0, 18)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PaymentServiceSelectionReq(value) => {
                    w.start_branch(e, 0, 0, 19)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PaymentServiceSelectionRes(value) => {
                    w.start_branch(e, 0, 0, 20)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PowerDeliveryReq(value) => {
                    w.start_branch(e, 0, 0, 21)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PowerDeliveryRes(value) => {
                    w.start_branch(e, 0, 0, 22)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PreChargeReq(value) => {
                    w.start_branch(e, 0, 0, 23)?;
                    value.encode_body(e)?;
                }
                BodyChoice::PreChargeRes(value) => {
                    w.start_branch(e, 0, 0, 24)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ServiceDetailReq(value) => {
                    w.start_branch(e, 0, 0, 25)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ServiceDetailRes(value) => {
                    w.start_branch(e, 0, 0, 26)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ServiceDiscoveryReq(value) => {
                    w.start_branch(e, 0, 0, 27)?;
                    value.encode_body(e)?;
                }
                BodyChoice::ServiceDiscoveryRes(value) => {
                    w.start_branch(e, 0, 0, 28)?;
                    value.encode_body(e)?;
                }
                BodyChoice::SessionSetupReq(value) => {
                    w.start_branch(e, 0, 0, 29)?;
                    value.encode_body(e)?;
                }
                BodyChoice::SessionSetupRes(value) => {
                    w.start_branch(e, 0, 0, 30)?;
                    value.encode_body(e)?;
                }
                BodyChoice::SessionStopReq(value) => {
                    w.start_branch(e, 0, 0, 31)?;
                    value.encode_body(e)?;
                }
                BodyChoice::SessionStopRes(value) => {
                    w.start_branch(e, 0, 0, 32)?;
                    value.encode_body(e)?;
                }
                BodyChoice::WeldingDetectionReq(value) => {
                    w.start_branch(e, 0, 0, 33)?;
                    value.encode_body(e)?;
                }
                BodyChoice::WeldingDetectionRes(value) => {
                    w.start_branch(e, 0, 0, 34)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Body {
    /// 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 = AuthorizationReq::decode_body(d)?;
                            BodyChoice::AuthorizationReq(value)
                        }
                        1 => {
                            let value = AuthorizationRes::decode_body(d)?;
                            BodyChoice::AuthorizationRes(value)
                        }
                        2 => {
                            let value = BodyBase::decode_body(d)?;
                            BodyChoice::BodyElement(value)
                        }
                        3 => {
                            let value = CableCheckReq::decode_body(d)?;
                            BodyChoice::CableCheckReq(value)
                        }
                        4 => {
                            let value = CableCheckRes::decode_body(d)?;
                            BodyChoice::CableCheckRes(value)
                        }
                        5 => {
                            let value = CertificateInstallationReq::decode_body(d)?;
                            BodyChoice::CertificateInstallationReq(value)
                        }
                        6 => {
                            let value = CertificateInstallationRes::decode_body(d)?;
                            BodyChoice::CertificateInstallationRes(value)
                        }
                        7 => {
                            let value = CertificateUpdateReq::decode_body(d)?;
                            BodyChoice::CertificateUpdateReq(value)
                        }
                        8 => {
                            let value = CertificateUpdateRes::decode_body(d)?;
                            BodyChoice::CertificateUpdateRes(value)
                        }
                        9 => {
                            let value = ChargeParameterDiscoveryReq::decode_body(d)?;
                            BodyChoice::ChargeParameterDiscoveryReq(value)
                        }
                        10 => {
                            let value = ChargeParameterDiscoveryRes::decode_body(d)?;
                            BodyChoice::ChargeParameterDiscoveryRes(value)
                        }
                        11 => {
                            let value = ChargingStatusReq::decode_body(d)?;
                            BodyChoice::ChargingStatusReq(value)
                        }
                        12 => {
                            let value = ChargingStatusRes::decode_body(d)?;
                            BodyChoice::ChargingStatusRes(value)
                        }
                        13 => {
                            let value = CurrentDemandReq::decode_body(d)?;
                            BodyChoice::CurrentDemandReq(value)
                        }
                        14 => {
                            let value = CurrentDemandRes::decode_body(d)?;
                            BodyChoice::CurrentDemandRes(value)
                        }
                        15 => {
                            let value = MeteringReceiptReq::decode_body(d)?;
                            BodyChoice::MeteringReceiptReq(value)
                        }
                        16 => {
                            let value = MeteringReceiptRes::decode_body(d)?;
                            BodyChoice::MeteringReceiptRes(value)
                        }
                        17 => {
                            let value = PaymentDetailsReq::decode_body(d)?;
                            BodyChoice::PaymentDetailsReq(value)
                        }
                        18 => {
                            let value = PaymentDetailsRes::decode_body(d)?;
                            BodyChoice::PaymentDetailsRes(value)
                        }
                        19 => {
                            let value = PaymentServiceSelectionReq::decode_body(d)?;
                            BodyChoice::PaymentServiceSelectionReq(value)
                        }
                        20 => {
                            let value = PaymentServiceSelectionRes::decode_body(d)?;
                            BodyChoice::PaymentServiceSelectionRes(value)
                        }
                        21 => {
                            let value = PowerDeliveryReq::decode_body(d)?;
                            BodyChoice::PowerDeliveryReq(value)
                        }
                        22 => {
                            let value = PowerDeliveryRes::decode_body(d)?;
                            BodyChoice::PowerDeliveryRes(value)
                        }
                        23 => {
                            let value = PreChargeReq::decode_body(d)?;
                            BodyChoice::PreChargeReq(value)
                        }
                        24 => {
                            let value = PreChargeRes::decode_body(d)?;
                            BodyChoice::PreChargeRes(value)
                        }
                        25 => {
                            let value = ServiceDetailReq::decode_body(d)?;
                            BodyChoice::ServiceDetailReq(value)
                        }
                        26 => {
                            let value = ServiceDetailRes::decode_body(d)?;
                            BodyChoice::ServiceDetailRes(value)
                        }
                        27 => {
                            let value = ServiceDiscoveryReq::decode_body(d)?;
                            BodyChoice::ServiceDiscoveryReq(value)
                        }
                        28 => {
                            let value = ServiceDiscoveryRes::decode_body(d)?;
                            BodyChoice::ServiceDiscoveryRes(value)
                        }
                        29 => {
                            let value = SessionSetupReq::decode_body(d)?;
                            BodyChoice::SessionSetupReq(value)
                        }
                        30 => {
                            let value = SessionSetupRes::decode_body(d)?;
                            BodyChoice::SessionSetupRes(value)
                        }
                        31 => {
                            let value = SessionStopReq::decode_body(d)?;
                            BodyChoice::SessionStopReq(value)
                        }
                        32 => {
                            let value = SessionStopRes::decode_body(d)?;
                            BodyChoice::SessionStopRes(value)
                        }
                        33 => {
                            let value = WeldingDetectionReq::decode_body(d)?;
                            BodyChoice::WeldingDetectionReq(value)
                        }
                        34 => {
                            let value = WeldingDetectionRes::decode_body(d)?;
                            BodyChoice::WeldingDetectionRes(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { choice: f_0 })
    }
}

/// `CableCheckReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CableCheckReq {
    /// `DC_EVStatus` element, 1..1.
    pub dc_ev_status: DCEVStatus,
}

impl CableCheckReq {
    /// 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 CableCheckReq {
    /// 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);
        // DC_EVStatus (1..1)
        {
            let item = &self.dc_ev_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CableCheckReq {
    /// 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 = DCEVStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { dc_ev_status: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `CableCheckResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CableCheckRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `DC_EVSEStatus` element, 1..1.
    pub dc_evse_status: DCEVSEStatus,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: EVSEProcessing,
}

impl CableCheckRes {
    /// 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 CableCheckRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // DC_EVSEStatus (1..1)
        {
            let item = &self.dc_evse_status;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            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(), EVSEProcessing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CableCheckRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = DCEVSEStatus::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = EVSEProcessing::from_index(d.nbit(EVSEProcessing::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            dc_evse_status: f_1.ok_or(ExiError::MissingElement)?,
            evse_processing: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `CanonicalizationMethodType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CanonicalizationMethod {
    /// `Algorithm` attribute, 1..1.
    pub algorithm: String,
    // `xs:any wildcard` is not modelled: its type needs XML signature machinery this
    // crate does not implement. Decoding one is refused.
}

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

impl CanonicalizationMethod {
    /// 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);
        // Algorithm (1..1)
        {
            let item = &self.algorithm;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(4), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // xs:any wildcard is never written.
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CanonicalizationMethod {
    /// 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 = d.string(ValueCtx(4), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                // `xs:any wildcard` is refused, not skipped.
                Step::Item { index: 1, .. } => return Err(ExiError::UnsupportedOption),
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { algorithm: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `CertificateChainType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateChain {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `Certificate` element, 1..1.
    pub certificate: Vec<u8>,
    /// `SubCertificates` element, 0..1.
    pub sub_certificates: Option<SubCertificates>,
}

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

impl CertificateChain {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(107), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // Certificate (1..1)
        {
            let item = &self.certificate;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(800))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // SubCertificates (0..1)
        if let Some(item) = &self.sub_certificates {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateChain {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(107), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(800))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = SubCertificates::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            certificate: f_1.ok_or(ExiError::MissingElement)?,
            sub_certificates: f_2,
        })
    }
}

/// `CertificateInstallationReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateInstallationReq {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `OEMProvisioningCert` element, 1..1.
    pub oem_provisioning_cert: Vec<u8>,
    /// `ListOfRootCertificateIDs` element, 1..1.
    pub list_of_root_certificate_i_ds: ListOfRootCertificateIDs,
}

impl CertificateInstallationReq {
    /// 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 CertificateInstallationReq {
    /// 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);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(106), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // OEMProvisioningCert (1..1)
        {
            let item = &self.oem_provisioning_cert;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(800))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ListOfRootCertificateIDs (1..1)
        {
            let item = &self.list_of_root_certificate_i_ds;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateInstallationReq {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(106), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(800))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = ListOfRootCertificateIDs::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            oem_provisioning_cert: f_1.ok_or(ExiError::MissingElement)?,
            list_of_root_certificate_i_ds: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `CertificateInstallationResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateInstallationRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `SAProvisioningCertificateChain` element, 1..1.
    pub sa_provisioning_certificate_chain: CertificateChain,
    /// `ContractSignatureCertChain` element, 1..1.
    pub contract_signature_cert_chain: CertificateChain,
    /// `ContractSignatureEncryptedPrivateKey` element, 1..1.
    pub contract_signature_encrypted_private_key: ContractSignatureEncryptedPrivateKey,
    /// `DHpublickey` element, 1..1.
    pub dh_public_key: DiffieHellmanPublickey,
    /// `eMAID` element, 1..1.
    pub e_maid: EMAID,
}

impl CertificateInstallationRes {
    /// 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, 1, 1, 1, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0],
        min: &[1, 1, 1, 1, 1, 1],
        max: &[1, 1, 1, 1, 1, 1],
    };
}

impl CertificateInstallationRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SAProvisioningCertificateChain (1..1)
        {
            let item = &self.sa_provisioning_certificate_chain;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ContractSignatureCertChain (1..1)
        {
            let item = &self.contract_signature_cert_chain;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // ContractSignatureEncryptedPrivateKey (1..1)
        {
            let item = &self.contract_signature_encrypted_private_key;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // DHpublickey (1..1)
        {
            let item = &self.dh_public_key;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // eMAID (1..1)
        {
            let item = &self.e_maid;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateInstallationRes {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = ContractSignatureEncryptedPrivateKey::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = DiffieHellmanPublickey::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = EMAID::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            sa_provisioning_certificate_chain: f_1.ok_or(ExiError::MissingElement)?,
            contract_signature_cert_chain: f_2.ok_or(ExiError::MissingElement)?,
            contract_signature_encrypted_private_key: f_3.ok_or(ExiError::MissingElement)?,
            dh_public_key: f_4.ok_or(ExiError::MissingElement)?,
            e_maid: f_5.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `CertificateUpdateReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateUpdateReq {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `ContractSignatureCertChain` element, 1..1.
    pub contract_signature_cert_chain: CertificateChain,
    /// `eMAID` element, 1..1.
    pub e_maid: String,
    /// `ListOfRootCertificateIDs` element, 1..1.
    pub list_of_root_certificate_i_ds: ListOfRootCertificateIDs,
}

impl CertificateUpdateReq {
    /// 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 CertificateUpdateReq {
    /// 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);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(106), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // ContractSignatureCertChain (1..1)
        {
            let item = &self.contract_signature_cert_chain;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // eMAID (1..1)
        {
            let item = &self.e_maid;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(211), item, Lengths::new(14, 15))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // ListOfRootCertificateIDs (1..1)
        {
            let item = &self.list_of_root_certificate_i_ds;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateUpdateReq {
    /// 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 = d.string(ValueCtx(106), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(211), Lengths::new(14, 15))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = ListOfRootCertificateIDs::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            contract_signature_cert_chain: f_1.ok_or(ExiError::MissingElement)?,
            e_maid: f_2.ok_or(ExiError::MissingElement)?,
            list_of_root_certificate_i_ds: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `CertificateUpdateResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateUpdateRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `SAProvisioningCertificateChain` element, 1..1.
    pub sa_provisioning_certificate_chain: CertificateChain,
    /// `ContractSignatureCertChain` element, 1..1.
    pub contract_signature_cert_chain: CertificateChain,
    /// `ContractSignatureEncryptedPrivateKey` element, 1..1.
    pub contract_signature_encrypted_private_key: ContractSignatureEncryptedPrivateKey,
    /// `DHpublickey` element, 1..1.
    pub dh_public_key: DiffieHellmanPublickey,
    /// `eMAID` element, 1..1.
    pub e_maid: EMAID,
    /// `RetryCounter` element, 0..1.
    pub retry_counter: Option<i16>,
}

impl CertificateUpdateRes {
    /// 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, 0],
        min: &[1, 1, 1, 1, 1, 1, 0],
        max: &[1, 1, 1, 1, 1, 1, 1],
    };
}

impl CertificateUpdateRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SAProvisioningCertificateChain (1..1)
        {
            let item = &self.sa_provisioning_certificate_chain;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ContractSignatureCertChain (1..1)
        {
            let item = &self.contract_signature_cert_chain;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // ContractSignatureEncryptedPrivateKey (1..1)
        {
            let item = &self.contract_signature_encrypted_private_key;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // DHpublickey (1..1)
        {
            let item = &self.dh_public_key;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // eMAID (1..1)
        {
            let item = &self.e_maid;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // RetryCounter (0..1)
        if let Some(item) = &self.retry_counter {
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateUpdateRes {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = ContractSignatureEncryptedPrivateKey::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = DiffieHellmanPublickey::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = EMAID::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    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_6 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            sa_provisioning_certificate_chain: f_1.ok_or(ExiError::MissingElement)?,
            contract_signature_cert_chain: f_2.ok_or(ExiError::MissingElement)?,
            contract_signature_encrypted_private_key: f_3.ok_or(ExiError::MissingElement)?,
            dh_public_key: f_4.ok_or(ExiError::MissingElement)?,
            e_maid: f_5.ok_or(ExiError::MissingElement)?,
            retry_counter: f_6,
        })
    }
}

/// The `choice of 3` alternatives of [`ChargeParameterDiscoveryReq`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargeParameterDiscoveryReqChoice {
    /// `AC_EVChargeParameter`
    ACEVChargeParameter(ACEVChargeParameter),
    /// `DC_EVChargeParameter`
    DCEVChargeParameter(DCEVChargeParameter),
    /// `EVChargeParameter`
    EVChargeParameter(EVChargeParameter),
}

impl ChargeParameterDiscoveryReqChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::ACEVChargeParameter(_) => "AC_EVChargeParameter",
            Self::DCEVChargeParameter(_) => "DC_EVChargeParameter",
            Self::EVChargeParameter(_) => "EVChargeParameter",
        }
    }
}

/// `ChargeParameterDiscoveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargeParameterDiscoveryReq {
    /// `MaxEntriesSAScheduleTuple` element, 0..1.
    pub max_entries_sa_schedule_tuple: Option<u16>,
    /// `RequestedEnergyTransferMode` element, 1..1.
    pub requested_energy_transfer_mode: EnergyTransferMode,
    /// `choice of 3` element, 1..1.
    pub choice: ChargeParameterDiscoveryReqChoice,
}

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

impl ChargeParameterDiscoveryReq {
    /// 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);
        // MaxEntriesSAScheduleTuple (0..1)
        if let Some(item) = &self.max_entries_sa_schedule_tuple {
            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);
        }
        // RequestedEnergyTransferMode (1..1)
        {
            let item = &self.requested_energy_transfer_mode;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EnergyTransferMode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // choice of 3 (1..1)
        {
            let item = &self.choice;
            match item {
                ChargeParameterDiscoveryReqChoice::ACEVChargeParameter(value) => {
                    w.start_branch(e, 2, 0, 0)?;
                    value.encode_body(e)?;
                }
                ChargeParameterDiscoveryReqChoice::DCEVChargeParameter(value) => {
                    w.start_branch(e, 2, 0, 1)?;
                    value.encode_body(e)?;
                }
                ChargeParameterDiscoveryReqChoice::EVChargeParameter(value) => {
                    w.start_branch(e, 2, 0, 2)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargeParameterDiscoveryReq {
    /// 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 = 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 = EnergyTransferMode::from_index(d.nbit(EnergyTransferMode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = ACEVChargeParameter::decode_body(d)?;
                            ChargeParameterDiscoveryReqChoice::ACEVChargeParameter(value)
                        }
                        1 => {
                            let value = DCEVChargeParameter::decode_body(d)?;
                            ChargeParameterDiscoveryReqChoice::DCEVChargeParameter(value)
                        }
                        2 => {
                            let value = EVChargeParameter::decode_body(d)?;
                            ChargeParameterDiscoveryReqChoice::EVChargeParameter(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            max_entries_sa_schedule_tuple: f_0,
            requested_energy_transfer_mode: f_1.ok_or(ExiError::MissingElement)?,
            choice: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`ChargeParameterDiscoveryRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargeParameterDiscoveryResChoice2 {
    /// `SAScheduleList`
    SAScheduleList(SAScheduleList),
    /// `SASchedules`
    SASchedules(SASchedules),
}

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

/// The `choice of 3` alternatives of [`ChargeParameterDiscoveryRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargeParameterDiscoveryResChoice3 {
    /// `AC_EVSEChargeParameter`
    ACEVSEChargeParameter(ACEVSEChargeParameter),
    /// `DC_EVSEChargeParameter`
    DCEVSEChargeParameter(DCEVSEChargeParameter),
    /// `EVSEChargeParameter`
    EVSEChargeParameter(EVSEChargeParameter),
}

impl ChargeParameterDiscoveryResChoice3 {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::ACEVSEChargeParameter(_) => "AC_EVSEChargeParameter",
            Self::DCEVSEChargeParameter(_) => "DC_EVSEChargeParameter",
            Self::EVSEChargeParameter(_) => "EVSEChargeParameter",
        }
    }
}

/// `ChargeParameterDiscoveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargeParameterDiscoveryRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: EVSEProcessing,
    /// `choice of 2` element, 0..1.
    pub choice_2: Option<ChargeParameterDiscoveryResChoice2>,
    /// `choice of 3` element, 1..1.
    pub choice_3: ChargeParameterDiscoveryResChoice3,
}

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

impl ChargeParameterDiscoveryRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EVSEProcessing (1..1)
        {
            let item = &self.evse_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EVSEProcessing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // choice of 2 (0..1)
        if let Some(item) = &self.choice_2 {
            match item {
                ChargeParameterDiscoveryResChoice2::SAScheduleList(value) => {
                    w.start_branch(e, 2, 0, 0)?;
                    value.encode_body(e)?;
                }
                ChargeParameterDiscoveryResChoice2::SASchedules(value) => {
                    w.start_branch(e, 2, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(2, 1);
        }
        // choice of 3 (1..1)
        {
            let item = &self.choice_3;
            match item {
                ChargeParameterDiscoveryResChoice3::ACEVSEChargeParameter(value) => {
                    w.start_branch(e, 3, 0, 0)?;
                    value.encode_body(e)?;
                }
                ChargeParameterDiscoveryResChoice3::DCEVSEChargeParameter(value) => {
                    w.start_branch(e, 3, 0, 1)?;
                    value.encode_body(e)?;
                }
                ChargeParameterDiscoveryResChoice3::EVSEChargeParameter(value) => {
                    w.start_branch(e, 3, 0, 2)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargeParameterDiscoveryRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = EVSEProcessing::from_index(d.nbit(EVSEProcessing::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = SAScheduleList::decode_body(d)?;
                            ChargeParameterDiscoveryResChoice2::SAScheduleList(value)
                        }
                        1 => {
                            let value = SASchedules::decode_body(d)?;
                            ChargeParameterDiscoveryResChoice2::SASchedules(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_2 = Some(value);
                }
                Step::Item { index: 3, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = ACEVSEChargeParameter::decode_body(d)?;
                            ChargeParameterDiscoveryResChoice3::ACEVSEChargeParameter(value)
                        }
                        1 => {
                            let value = DCEVSEChargeParameter::decode_body(d)?;
                            ChargeParameterDiscoveryResChoice3::DCEVSEChargeParameter(value)
                        }
                        2 => {
                            let value = EVSEChargeParameter::decode_body(d)?;
                            ChargeParameterDiscoveryResChoice3::EVSEChargeParameter(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            evse_processing: f_1.ok_or(ExiError::MissingElement)?,
            choice_2: f_2,
            choice_3: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ChargeServiceType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargeService {
    /// `ServiceID` element, 1..1.
    pub service_id: u16,
    /// `ServiceName` element, 0..1.
    pub service_name: Option<String>,
    /// `ServiceCategory` element, 1..1.
    pub service_category: ServiceCategory,
    /// `ServiceScope` element, 0..1.
    pub service_scope: Option<String>,
    /// `FreeService` element, 1..1.
    pub free_service: bool,
    /// `SupportedEnergyTransferMode` element, 1..1.
    pub supported_energy_transfer_mode: SupportedEnergyTransferMode,
}

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

impl ChargeService {
    /// 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);
        // ServiceID (1..1)
        {
            let item = &self.service_id;
            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);
        }
        // ServiceName (0..1)
        if let Some(item) = &self.service_name {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(175), item, Lengths::max(32))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ServiceCategory (1..1)
        {
            let item = &self.service_category;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ServiceCategory::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // ServiceScope (0..1)
        if let Some(item) = &self.service_scope {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(178), item, Lengths::max(64))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // FreeService (1..1)
        {
            let item = &self.free_service;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // SupportedEnergyTransferMode (1..1)
        {
            let item = &self.supported_energy_transfer_mode;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargeService {
    /// 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;
        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 = d.string(ValueCtx(175), Lengths::max(32))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ServiceCategory::from_index(d.nbit(ServiceCategory::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.string(ValueCtx(178), Lengths::max(64))?;
                    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.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = SupportedEnergyTransferMode::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            service_id: f_0.ok_or(ExiError::MissingElement)?,
            service_name: f_1,
            service_category: f_2.ok_or(ExiError::MissingElement)?,
            service_scope: f_3,
            free_service: f_4.ok_or(ExiError::MissingElement)?,
            supported_energy_transfer_mode: f_5.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ChargingProfileType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfile {
    /// `ProfileEntry` element, 1..24.
    pub profile_entry: Vec<ProfileEntry>,
}

impl ChargingProfile {
    /// 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: &[24] };
}

impl ChargingProfile {
    /// 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);
        // ProfileEntry (1..24)
        {
            let items = &self.profile_entry;
            let count = items.len() as u32;
            if count < 1 || count > 24 {
                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 ChargingProfile {
    /// 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 = ProfileEntry::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            profile_entry: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `ChargingStatusReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingStatusReq;

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

impl ChargingStatusReq {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargingStatusReq {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// `ChargingStatusResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingStatusRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `EVSEID` element, 1..1.
    pub evse_id: String,
    /// `SAScheduleTupleID` element, 1..1.
    pub sa_schedule_tuple_id: u8,
    /// `EVSEMaxCurrent` element, 0..1.
    pub evse_max_current: Option<PhysicalValue>,
    /// `MeterInfo` element, 0..1.
    pub meter_info: Option<MeterInfo>,
    /// `ReceiptRequired` element, 0..1.
    pub receipt_required: Option<bool>,
    /// `AC_EVSEStatus` element, 1..1.
    pub ac_evse_status: ACEVSEStatus,
}

impl ChargingStatusRes {
    /// 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, 3, 2, 2, 1, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0],
        min: &[1, 1, 1, 0, 0, 0, 1],
        max: &[1, 1, 1, 1, 1, 1, 1],
    };
}

impl ChargingStatusRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EVSEID (1..1)
        {
            let item = &self.evse_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(72), item, Lengths::new(7, 37))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // SAScheduleTupleID (1..1)
        {
            let item = &self.sa_schedule_tuple_id;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVSEMaxCurrent (0..1)
        if let Some(item) = &self.evse_max_current {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // MeterInfo (0..1)
        if let Some(item) = &self.meter_info {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // ReceiptRequired (0..1)
        if let Some(item) = &self.receipt_required {
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // AC_EVSEStatus (1..1)
        {
            let item = &self.ac_evse_status;
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargingStatusRes {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    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(72), Lengths::new(7, 37))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(1, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = MeterInfo::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, .. } => {
                    let value = ACEVSEStatus::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            evse_id: f_1.ok_or(ExiError::MissingElement)?,
            sa_schedule_tuple_id: f_2.ok_or(ExiError::MissingElement)?,
            evse_max_current: f_3,
            meter_info: f_4,
            receipt_required: f_5,
            ac_evse_status: f_6.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ConsumptionCostType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ConsumptionCost {
    /// `startValue` element, 1..1.
    pub start_value: PhysicalValue,
    /// `Cost` element, 1..3.
    pub cost: Vec<Cost>,
}

impl ConsumptionCost {
    /// 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, 1],
        max: &[1, 3],
    };
}

impl ConsumptionCost {
    /// 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);
        // startValue (1..1)
        {
            let item = &self.start_value;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // Cost (1..3)
        {
            let items = &self.cost;
            let count = items.len() as u32;
            if count < 1 || count > 3 {
                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 ConsumptionCost {
    /// 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, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = Cost::decode_body(d)?;
                    f_1.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            start_value: f_0.ok_or(ExiError::MissingElement)?,
            cost: {
                if (f_1.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_1
            },
        })
    }
}

/// `ContractSignatureEncryptedPrivateKeyType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ContractSignatureEncryptedPrivateKey {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `character data` attribute, 1..1.
    pub value: Vec<u8>,
}

impl ContractSignatureEncryptedPrivateKey {
    /// 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 ContractSignatureEncryptedPrivateKey {
    /// 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);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(107), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // character data (1..1)
        {
            let item = &self.value;
            w.start(e, 1, 0)?;
            e.binary(item, Lengths::max(48))?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ContractSignatureEncryptedPrivateKey {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(107), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.binary(Lengths::max(48))?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            value: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `CostType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Cost {
    /// `costKind` element, 1..1.
    pub cost_kind: CostKind,
    /// `amount` element, 1..1.
    pub amount: u32,
    /// `amountMultiplier` element, 0..1.
    pub amount_multiplier: Option<i8>,
}

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

impl Cost {
    /// 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);
        // costKind (1..1)
        {
            let item = &self.cost_kind;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), CostKind::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // amount (1..1)
        {
            let item = &self.amount;
            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);
        }
        // amountMultiplier (0..1)
        if let Some(item) = &self.amount_multiplier {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), -3, 3)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Cost {
    /// 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 = CostKind::from_index(d.nbit(CostKind::WIDTH)?)?;
                    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 { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i8::try_from(d.restricted(-3, 3)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            cost_kind: f_0.ok_or(ExiError::MissingElement)?,
            amount: f_1.ok_or(ExiError::MissingElement)?,
            amount_multiplier: f_2,
        })
    }
}

/// `CurrentDemandReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CurrentDemandReq {
    /// `DC_EVStatus` element, 1..1.
    pub dc_ev_status: DCEVStatus,
    /// `EVTargetCurrent` element, 1..1.
    pub ev_target_current: PhysicalValue,
    /// `EVMaximumVoltageLimit` element, 0..1.
    pub ev_maximum_voltage_limit: Option<PhysicalValue>,
    /// `EVMaximumCurrentLimit` element, 0..1.
    pub ev_maximum_current_limit: Option<PhysicalValue>,
    /// `EVMaximumPowerLimit` element, 0..1.
    pub ev_maximum_power_limit: Option<PhysicalValue>,
    /// `BulkChargingComplete` element, 0..1.
    pub bulk_charging_complete: Option<bool>,
    /// `ChargingComplete` element, 1..1.
    pub charging_complete: bool,
    /// `RemainingTimeToFullSoC` element, 0..1.
    pub remaining_time_to_full_soc: Option<PhysicalValue>,
    /// `RemainingTimeToBulkSoC` element, 0..1.
    pub remaining_time_to_bulk_soc: Option<PhysicalValue>,
    /// `EVTargetVoltage` element, 1..1.
    pub ev_target_voltage: PhysicalValue,
}

impl CurrentDemandReq {
    /// 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, 3, 3, 2, 2, 1, 2, 2, 1, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        min: &[1, 1, 0, 0, 0, 0, 1, 0, 0, 1],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    };
}

impl CurrentDemandReq {
    /// 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);
        // DC_EVStatus (1..1)
        {
            let item = &self.dc_ev_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVTargetCurrent (1..1)
        {
            let item = &self.ev_target_current;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMaximumVoltageLimit (0..1)
        if let Some(item) = &self.ev_maximum_voltage_limit {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVMaximumCurrentLimit (0..1)
        if let Some(item) = &self.ev_maximum_current_limit {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVMaximumPowerLimit (0..1)
        if let Some(item) = &self.ev_maximum_power_limit {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // BulkChargingComplete (0..1)
        if let Some(item) = &self.bulk_charging_complete {
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // ChargingComplete (1..1)
        {
            let item = &self.charging_complete;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // RemainingTimeToFullSoC (0..1)
        if let Some(item) = &self.remaining_time_to_full_soc {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // RemainingTimeToBulkSoC (0..1)
        if let Some(item) = &self.remaining_time_to_bulk_soc {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVTargetVoltage (1..1)
        {
            let item = &self.ev_target_voltage;
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CurrentDemandReq {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = DCEVStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = PhysicalValue::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.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            dc_ev_status: f_0.ok_or(ExiError::MissingElement)?,
            ev_target_current: f_1.ok_or(ExiError::MissingElement)?,
            ev_maximum_voltage_limit: f_2,
            ev_maximum_current_limit: f_3,
            ev_maximum_power_limit: f_4,
            bulk_charging_complete: f_5,
            charging_complete: f_6.ok_or(ExiError::MissingElement)?,
            remaining_time_to_full_soc: f_7,
            remaining_time_to_bulk_soc: f_8,
            ev_target_voltage: f_9.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `CurrentDemandResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CurrentDemandRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `DC_EVSEStatus` element, 1..1.
    pub dc_evse_status: DCEVSEStatus,
    /// `EVSEPresentVoltage` element, 1..1.
    pub evse_present_voltage: PhysicalValue,
    /// `EVSEPresentCurrent` element, 1..1.
    pub evse_present_current: PhysicalValue,
    /// `EVSECurrentLimitAchieved` element, 1..1.
    pub evse_current_limit_achieved: bool,
    /// `EVSEVoltageLimitAchieved` element, 1..1.
    pub evse_voltage_limit_achieved: bool,
    /// `EVSEPowerLimitAchieved` element, 1..1.
    pub evse_power_limit_achieved: bool,
    /// `EVSEMaximumVoltageLimit` element, 0..1.
    pub evse_maximum_voltage_limit: Option<PhysicalValue>,
    /// `EVSEMaximumCurrentLimit` element, 0..1.
    pub evse_maximum_current_limit: Option<PhysicalValue>,
    /// `EVSEMaximumPowerLimit` element, 0..1.
    pub evse_maximum_power_limit: Option<PhysicalValue>,
    /// `EVSEID` element, 1..1.
    pub evse_id: String,
    /// `SAScheduleTupleID` element, 1..1.
    pub sa_schedule_tuple_id: u8,
    /// `MeterInfo` element, 0..1.
    pub meter_info: Option<MeterInfo>,
    /// `ReceiptRequired` element, 0..1.
    pub receipt_required: Option<bool>,
}

impl CurrentDemandRes {
    /// 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, 14],
        width: &[1, 1, 1, 1, 1, 1, 1, 3, 2, 2, 1, 1, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        min: &[1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    };
}

impl CurrentDemandRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // DC_EVSEStatus (1..1)
        {
            let item = &self.dc_evse_status;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEPresentVoltage (1..1)
        {
            let item = &self.evse_present_voltage;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVSEPresentCurrent (1..1)
        {
            let item = &self.evse_present_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVSECurrentLimitAchieved (1..1)
        {
            let item = &self.evse_current_limit_achieved;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // EVSEVoltageLimitAchieved (1..1)
        {
            let item = &self.evse_voltage_limit_achieved;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // EVSEPowerLimitAchieved (1..1)
        {
            let item = &self.evse_power_limit_achieved;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // EVSEMaximumVoltageLimit (0..1)
        if let Some(item) = &self.evse_maximum_voltage_limit {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVSEMaximumCurrentLimit (0..1)
        if let Some(item) = &self.evse_maximum_current_limit {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVSEMaximumPowerLimit (0..1)
        if let Some(item) = &self.evse_maximum_power_limit {
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // EVSEID (1..1)
        {
            let item = &self.evse_id;
            w.start(e, 10, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(72), item, Lengths::new(7, 37))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(10, 1);
        }
        // SAScheduleTupleID (1..1)
        {
            let item = &self.sa_schedule_tuple_id;
            w.start(e, 11, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(11, 1);
        }
        // MeterInfo (0..1)
        if let Some(item) = &self.meter_info {
            w.start(e, 12, 0)?;
            item.encode_body(e)?;
            w.finish(12, 1);
        }
        // ReceiptRequired (0..1)
        if let Some(item) = &self.receipt_required {
            w.start(e, 13, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(13, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CurrentDemandRes {
    /// 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 = None;
        let mut f_13 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = DCEVSEStatus::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    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.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(72), Lengths::new(7, 37))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_10 = Some(value);
                }
                Step::Item { index: 11, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(1, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_11 = Some(value);
                }
                Step::Item { index: 12, .. } => {
                    let value = MeterInfo::decode_body(d)?;
                    f_12 = Some(value);
                }
                Step::Item { index: 13, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_13 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            dc_evse_status: f_1.ok_or(ExiError::MissingElement)?,
            evse_present_voltage: f_2.ok_or(ExiError::MissingElement)?,
            evse_present_current: f_3.ok_or(ExiError::MissingElement)?,
            evse_current_limit_achieved: f_4.ok_or(ExiError::MissingElement)?,
            evse_voltage_limit_achieved: f_5.ok_or(ExiError::MissingElement)?,
            evse_power_limit_achieved: f_6.ok_or(ExiError::MissingElement)?,
            evse_maximum_voltage_limit: f_7,
            evse_maximum_current_limit: f_8,
            evse_maximum_power_limit: f_9,
            evse_id: f_10.ok_or(ExiError::MissingElement)?,
            sa_schedule_tuple_id: f_11.ok_or(ExiError::MissingElement)?,
            meter_info: f_12,
            receipt_required: f_13,
        })
    }
}

/// `DC_EVChargeParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCEVChargeParameter {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `DC_EVStatus` element, 1..1.
    pub dc_ev_status: DCEVStatus,
    /// `EVMaximumCurrentLimit` element, 1..1.
    pub ev_maximum_current_limit: PhysicalValue,
    /// `EVMaximumPowerLimit` element, 0..1.
    pub ev_maximum_power_limit: Option<PhysicalValue>,
    /// `EVMaximumVoltageLimit` element, 1..1.
    pub ev_maximum_voltage_limit: PhysicalValue,
    /// `EVEnergyCapacity` element, 0..1.
    pub ev_energy_capacity: Option<PhysicalValue>,
    /// `EVEnergyRequest` element, 0..1.
    pub ev_energy_request: Option<PhysicalValue>,
    /// `FullSOC` element, 0..1.
    pub full_soc: Option<u8>,
    /// `BulkSOC` element, 0..1.
    pub bulk_soc: Option<u8>,
}

impl DCEVChargeParameter {
    /// 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: &[2, 1, 1, 2, 1, 3, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 0],
        min: &[0, 1, 1, 0, 1, 0, 0, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 1],
    };
}

impl DCEVChargeParameter {
    /// 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);
        // DepartureTime (0..1)
        if let Some(item) = &self.departure_time {
            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);
        }
        // DC_EVStatus (1..1)
        {
            let item = &self.dc_ev_status;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMaximumCurrentLimit (1..1)
        {
            let item = &self.ev_maximum_current_limit;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVMaximumPowerLimit (0..1)
        if let Some(item) = &self.ev_maximum_power_limit {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVMaximumVoltageLimit (1..1)
        {
            let item = &self.ev_maximum_voltage_limit;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVEnergyCapacity (0..1)
        if let Some(item) = &self.ev_energy_capacity {
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVEnergyRequest (0..1)
        if let Some(item) = &self.ev_energy_request {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // FullSOC (0..1)
        if let Some(item) = &self.full_soc {
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 1);
        }
        // BulkSOC (0..1)
        if let Some(item) = &self.bulk_soc {
            w.start(e, 8, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(8, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCEVChargeParameter {
    /// 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;
        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 = DCEVStatus::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 100)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 100)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_8 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            departure_time: f_0,
            dc_ev_status: f_1.ok_or(ExiError::MissingElement)?,
            ev_maximum_current_limit: f_2.ok_or(ExiError::MissingElement)?,
            ev_maximum_power_limit: f_3,
            ev_maximum_voltage_limit: f_4.ok_or(ExiError::MissingElement)?,
            ev_energy_capacity: f_5,
            ev_energy_request: f_6,
            full_soc: f_7,
            bulk_soc: f_8,
        })
    }
}

/// `DC_EVErrorCodeType`.
///
/// 12 values, so 4 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 DCEVErrorCode {
    /// `NO_ERROR`
    NOERROR = 0,
    /// `FAILED_RESSTemperatureInhibit`
    FAILEDRESSTemperatureInhibit = 1,
    /// `FAILED_EVShiftPosition`
    FAILEDEVShiftPosition = 2,
    /// `FAILED_ChargerConnectorLockFault`
    FAILEDChargerConnectorLockFault = 3,
    /// `FAILED_EVRESSMalfunction`
    FAILEDEVRESSMalfunction = 4,
    /// `FAILED_ChargingCurrentdifferential`
    FAILEDChargingCurrentdifferential = 5,
    /// `FAILED_ChargingVoltageOutOfRange`
    FAILEDChargingVoltageOutOfRange = 6,
    /// `Reserved_A`
    ReservedA = 7,
    /// `Reserved_B`
    ReservedB = 8,
    /// `Reserved_C`
    ReservedC = 9,
    /// `FAILED_ChargingSystemIncompatibility`
    FAILEDChargingSystemIncompatibility = 10,
    /// `NoData`
    NoData = 11,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 12] = [
        Self::NOERROR,
        Self::FAILEDRESSTemperatureInhibit,
        Self::FAILEDEVShiftPosition,
        Self::FAILEDChargerConnectorLockFault,
        Self::FAILEDEVRESSMalfunction,
        Self::FAILEDChargingCurrentdifferential,
        Self::FAILEDChargingVoltageOutOfRange,
        Self::ReservedA,
        Self::ReservedB,
        Self::ReservedC,
        Self::FAILEDChargingSystemIncompatibility,
        Self::NoData,
    ];

    /// 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::NOERROR,
            1 => Self::FAILEDRESSTemperatureInhibit,
            2 => Self::FAILEDEVShiftPosition,
            3 => Self::FAILEDChargerConnectorLockFault,
            4 => Self::FAILEDEVRESSMalfunction,
            5 => Self::FAILEDChargingCurrentdifferential,
            6 => Self::FAILEDChargingVoltageOutOfRange,
            7 => Self::ReservedA,
            8 => Self::ReservedB,
            9 => Self::ReservedC,
            10 => Self::FAILEDChargingSystemIncompatibility,
            11 => Self::NoData,
            _ => 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::NOERROR => "NO_ERROR",
            Self::FAILEDRESSTemperatureInhibit => "FAILED_RESSTemperatureInhibit",
            Self::FAILEDEVShiftPosition => "FAILED_EVShiftPosition",
            Self::FAILEDChargerConnectorLockFault => "FAILED_ChargerConnectorLockFault",
            Self::FAILEDEVRESSMalfunction => "FAILED_EVRESSMalfunction",
            Self::FAILEDChargingCurrentdifferential => "FAILED_ChargingCurrentdifferential",
            Self::FAILEDChargingVoltageOutOfRange => "FAILED_ChargingVoltageOutOfRange",
            Self::ReservedA => "Reserved_A",
            Self::ReservedB => "Reserved_B",
            Self::ReservedC => "Reserved_C",
            Self::FAILEDChargingSystemIncompatibility => "FAILED_ChargingSystemIncompatibility",
            Self::NoData => "NoData",
        }
    }
}

/// `DC_EVPowerDeliveryParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCEVPowerDeliveryParameter {
    /// `DC_EVStatus` element, 1..1.
    pub dc_ev_status: DCEVStatus,
    /// `BulkChargingComplete` element, 0..1.
    pub bulk_charging_complete: Option<bool>,
    /// `ChargingComplete` element, 1..1.
    pub charging_complete: bool,
}

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

impl DCEVPowerDeliveryParameter {
    /// 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);
        // DC_EVStatus (1..1)
        {
            let item = &self.dc_ev_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // BulkChargingComplete (0..1)
        if let Some(item) = &self.bulk_charging_complete {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ChargingComplete (1..1)
        {
            let item = &self.charging_complete;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCEVPowerDeliveryParameter {
    /// 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, .. } => {
                    let value = DCEVStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    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.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            dc_ev_status: f_0.ok_or(ExiError::MissingElement)?,
            bulk_charging_complete: f_1,
            charging_complete: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DC_EVSEChargeParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCEVSEChargeParameter {
    /// `DC_EVSEStatus` element, 1..1.
    pub dc_evse_status: DCEVSEStatus,
    /// `EVSEMaximumCurrentLimit` element, 1..1.
    pub evse_maximum_current_limit: PhysicalValue,
    /// `EVSEMaximumPowerLimit` element, 1..1.
    pub evse_maximum_power_limit: PhysicalValue,
    /// `EVSEMaximumVoltageLimit` element, 1..1.
    pub evse_maximum_voltage_limit: PhysicalValue,
    /// `EVSEMinimumCurrentLimit` element, 1..1.
    pub evse_minimum_current_limit: PhysicalValue,
    /// `EVSEMinimumVoltageLimit` element, 1..1.
    pub evse_minimum_voltage_limit: PhysicalValue,
    /// `EVSECurrentRegulationTolerance` element, 0..1.
    pub evse_current_regulation_tolerance: Option<PhysicalValue>,
    /// `EVSEPeakCurrentRipple` element, 1..1.
    pub evse_peak_current_ripple: PhysicalValue,
    /// `EVSEEnergyToBeDelivered` element, 0..1.
    pub evse_energy_to_be_delivered: Option<PhysicalValue>,
}

impl DCEVSEChargeParameter {
    /// 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, 1, 1, 1, 1, 1, 2, 1, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0, 0],
        min: &[1, 1, 1, 1, 1, 1, 0, 1, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1, 1],
    };
}

impl DCEVSEChargeParameter {
    /// 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);
        // DC_EVSEStatus (1..1)
        {
            let item = &self.dc_evse_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVSEMaximumCurrentLimit (1..1)
        {
            let item = &self.evse_maximum_current_limit;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEMaximumPowerLimit (1..1)
        {
            let item = &self.evse_maximum_power_limit;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVSEMaximumVoltageLimit (1..1)
        {
            let item = &self.evse_maximum_voltage_limit;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVSEMinimumCurrentLimit (1..1)
        {
            let item = &self.evse_minimum_current_limit;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEMinimumVoltageLimit (1..1)
        {
            let item = &self.evse_minimum_voltage_limit;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSECurrentRegulationTolerance (0..1)
        if let Some(item) = &self.evse_current_regulation_tolerance {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVSEPeakCurrentRipple (1..1)
        {
            let item = &self.evse_peak_current_ripple;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVSEEnergyToBeDelivered (0..1)
        if let Some(item) = &self.evse_energy_to_be_delivered {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCEVSEChargeParameter {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = DCEVSEStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            dc_evse_status: f_0.ok_or(ExiError::MissingElement)?,
            evse_maximum_current_limit: f_1.ok_or(ExiError::MissingElement)?,
            evse_maximum_power_limit: f_2.ok_or(ExiError::MissingElement)?,
            evse_maximum_voltage_limit: f_3.ok_or(ExiError::MissingElement)?,
            evse_minimum_current_limit: f_4.ok_or(ExiError::MissingElement)?,
            evse_minimum_voltage_limit: f_5.ok_or(ExiError::MissingElement)?,
            evse_current_regulation_tolerance: f_6,
            evse_peak_current_ripple: f_7.ok_or(ExiError::MissingElement)?,
            evse_energy_to_be_delivered: f_8,
        })
    }
}

/// `DC_EVSEStatusCodeType`.
///
/// 12 values, so 4 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 DCEVSEStatusCode {
    /// `EVSE_NotReady`
    EVSENotReady = 0,
    /// `EVSE_Ready`
    EVSEReady = 1,
    /// `EVSE_Shutdown`
    EVSEShutdown = 2,
    /// `EVSE_UtilityInterruptEvent`
    EVSEUtilityInterruptEvent = 3,
    /// `EVSE_IsolationMonitoringActive`
    EVSEIsolationMonitoringActive = 4,
    /// `EVSE_EmergencyShutdown`
    EVSEEmergencyShutdown = 5,
    /// `EVSE_Malfunction`
    EVSEMalfunction = 6,
    /// `Reserved_8`
    Reserved8 = 7,
    /// `Reserved_9`
    Reserved9 = 8,
    /// `Reserved_A`
    ReservedA = 9,
    /// `Reserved_B`
    ReservedB = 10,
    /// `Reserved_C`
    ReservedC = 11,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 12] = [
        Self::EVSENotReady,
        Self::EVSEReady,
        Self::EVSEShutdown,
        Self::EVSEUtilityInterruptEvent,
        Self::EVSEIsolationMonitoringActive,
        Self::EVSEEmergencyShutdown,
        Self::EVSEMalfunction,
        Self::Reserved8,
        Self::Reserved9,
        Self::ReservedA,
        Self::ReservedB,
        Self::ReservedC,
    ];

    /// 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::EVSENotReady,
            1 => Self::EVSEReady,
            2 => Self::EVSEShutdown,
            3 => Self::EVSEUtilityInterruptEvent,
            4 => Self::EVSEIsolationMonitoringActive,
            5 => Self::EVSEEmergencyShutdown,
            6 => Self::EVSEMalfunction,
            7 => Self::Reserved8,
            8 => Self::Reserved9,
            9 => Self::ReservedA,
            10 => Self::ReservedB,
            11 => Self::ReservedC,
            _ => 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::EVSENotReady => "EVSE_NotReady",
            Self::EVSEReady => "EVSE_Ready",
            Self::EVSEShutdown => "EVSE_Shutdown",
            Self::EVSEUtilityInterruptEvent => "EVSE_UtilityInterruptEvent",
            Self::EVSEIsolationMonitoringActive => "EVSE_IsolationMonitoringActive",
            Self::EVSEEmergencyShutdown => "EVSE_EmergencyShutdown",
            Self::EVSEMalfunction => "EVSE_Malfunction",
            Self::Reserved8 => "Reserved_8",
            Self::Reserved9 => "Reserved_9",
            Self::ReservedA => "Reserved_A",
            Self::ReservedB => "Reserved_B",
            Self::ReservedC => "Reserved_C",
        }
    }
}

/// `DC_EVSEStatusType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCEVSEStatus {
    /// `NotificationMaxDelay` element, 1..1.
    pub notification_max_delay: u16,
    /// `EVSENotification` element, 1..1.
    pub evse_notification: EVSENotification,
    /// `EVSEIsolationStatus` element, 0..1.
    pub evse_isolation_status: Option<IsolationLevel>,
    /// `EVSEStatusCode` element, 1..1.
    pub evse_status_code: DCEVSEStatusCode,
}

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

impl DCEVSEStatus {
    /// 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);
        // NotificationMaxDelay (1..1)
        {
            let item = &self.notification_max_delay;
            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);
        }
        // EVSENotification (1..1)
        {
            let item = &self.evse_notification;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EVSENotification::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEIsolationStatus (0..1)
        if let Some(item) = &self.evse_isolation_status {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), IsolationLevel::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVSEStatusCode (1..1)
        {
            let item = &self.evse_status_code;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), DCEVSEStatusCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCEVSEStatus {
    /// 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 = 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 = EVSENotification::from_index(d.nbit(EVSENotification::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 = IsolationLevel::from_index(d.nbit(IsolationLevel::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 = DCEVSEStatusCode::from_index(d.nbit(DCEVSEStatusCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            notification_max_delay: f_0.ok_or(ExiError::MissingElement)?,
            evse_notification: f_1.ok_or(ExiError::MissingElement)?,
            evse_isolation_status: f_2,
            evse_status_code: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DC_EVStatusType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCEVStatus {
    /// `EVReady` element, 1..1.
    pub ev_ready: bool,
    /// `EVErrorCode` element, 1..1.
    pub ev_error_code: DCEVErrorCode,
    /// `EVRESSSOC` element, 1..1.
    pub ev_ress_soc: u8,
}

impl DCEVStatus {
    /// 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 DCEVStatus {
    /// 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);
        // EVReady (1..1)
        {
            let item = &self.ev_ready;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EVErrorCode (1..1)
        {
            let item = &self.ev_error_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), DCEVErrorCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVRESSSOC (1..1)
        {
            let item = &self.ev_ress_soc;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCEVStatus {
    /// 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 = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = DCEVErrorCode::from_index(d.nbit(DCEVErrorCode::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 = u8::try_from(d.restricted(0, 100)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ev_ready: f_0.ok_or(ExiError::MissingElement)?,
            ev_error_code: f_1.ok_or(ExiError::MissingElement)?,
            ev_ress_soc: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DiffieHellmanPublickeyType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DiffieHellmanPublickey {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `character data` attribute, 1..1.
    pub value: Vec<u8>,
}

impl DiffieHellmanPublickey {
    /// 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 DiffieHellmanPublickey {
    /// 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);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(107), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // character data (1..1)
        {
            let item = &self.value;
            w.start(e, 1, 0)?;
            e.binary(item, Lengths::max(65))?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DiffieHellmanPublickey {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(107), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.binary(Lengths::max(65))?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            value: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DigestMethodType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DigestMethod {
    /// `Algorithm` attribute, 1..1.
    pub algorithm: String,
    // `xs:any wildcard` is not modelled: its type needs XML signature machinery this
    // crate does not implement. Decoding one is refused.
}

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

impl DigestMethod {
    /// 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);
        // Algorithm (1..1)
        {
            let item = &self.algorithm;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(4), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // xs:any wildcard is never written.
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DigestMethod {
    /// 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 = d.string(ValueCtx(4), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                // `xs:any wildcard` is refused, not skipped.
                Step::Item { index: 1, .. } => return Err(ExiError::UnsupportedOption),
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { algorithm: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `EMAIDType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EMAID {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `character data` attribute, 1..1.
    pub value: String,
}

impl EMAID {
    /// 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 EMAID {
    /// 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);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(107), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // character data (1..1)
        {
            let item = &self.value;
            w.start(e, 1, 0)?;
            e.string(ValueCtx(0), item, Lengths::new(14, 15))?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EMAID {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(107), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.string(ValueCtx(0), Lengths::new(14, 15))?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            value: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `EVChargeParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVChargeParameter {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
}

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

impl EVChargeParameter {
    /// 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);
        // DepartureTime (0..1)
        if let Some(item) = &self.departure_time {
            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);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EVChargeParameter {
    /// 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, .. } => {
                    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 { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { departure_time: f_0 })
    }
}

/// `EVPowerDeliveryParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPowerDeliveryParameter;

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

impl EVPowerDeliveryParameter {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EVPowerDeliveryParameter {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// `EVSEChargeParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVSEChargeParameter;

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

impl EVSEChargeParameter {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EVSEChargeParameter {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// `EVSENotificationType`.
///
/// 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 EVSENotification {
    /// `None`
    None = 0,
    /// `StopCharging`
    StopCharging = 1,
    /// `ReNegotiation`
    ReNegotiation = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::None, Self::StopCharging, Self::ReNegotiation];

    /// 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::None,
            1 => Self::StopCharging,
            2 => Self::ReNegotiation,
            _ => 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::None => "None",
            Self::StopCharging => "StopCharging",
            Self::ReNegotiation => "ReNegotiation",
        }
    }
}

/// `EVSEProcessingType`.
///
/// 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 EVSEProcessing {
    /// `Finished`
    Finished = 0,
    /// `Ongoing`
    Ongoing = 1,
    /// `Ongoing_WaitingForCustomerInteraction`
    OngoingWaitingForCustomerInteraction = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] =
        [Self::Finished, Self::Ongoing, Self::OngoingWaitingForCustomerInteraction];

    /// 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::Finished,
            1 => Self::Ongoing,
            2 => Self::OngoingWaitingForCustomerInteraction,
            _ => 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::Finished => "Finished",
            Self::Ongoing => "Ongoing",
            Self::OngoingWaitingForCustomerInteraction => "Ongoing_WaitingForCustomerInteraction",
        }
    }
}

/// `EVSEStatusType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVSEStatus {
    /// `NotificationMaxDelay` element, 1..1.
    pub notification_max_delay: u16,
    /// `EVSENotification` element, 1..1.
    pub evse_notification: EVSENotification,
}

impl EVSEStatus {
    /// 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 EVSEStatus {
    /// 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);
        // NotificationMaxDelay (1..1)
        {
            let item = &self.notification_max_delay;
            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);
        }
        // EVSENotification (1..1)
        {
            let item = &self.evse_notification;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EVSENotification::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EVSEStatus {
    /// 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 = EVSENotification::from_index(d.nbit(EVSENotification::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            notification_max_delay: f_0.ok_or(ExiError::MissingElement)?,
            evse_notification: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `EVStatusType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVStatus;

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

impl EVStatus {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EVStatus {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// `EnergyTransferModeType`.
///
/// 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 EnergyTransferMode {
    /// `AC_single_phase_core`
    ACSinglePhaseCore = 0,
    /// `AC_three_phase_core`
    ACThreePhaseCore = 1,
    /// `DC_core`
    DCCore = 2,
    /// `DC_extended`
    DCExtended = 3,
    /// `DC_combo_core`
    DCComboCore = 4,
    /// `DC_unique`
    DCUnique = 5,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 6] = [
        Self::ACSinglePhaseCore,
        Self::ACThreePhaseCore,
        Self::DCCore,
        Self::DCExtended,
        Self::DCComboCore,
        Self::DCUnique,
    ];

    /// 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::ACSinglePhaseCore,
            1 => Self::ACThreePhaseCore,
            2 => Self::DCCore,
            3 => Self::DCExtended,
            4 => Self::DCComboCore,
            5 => Self::DCUnique,
            _ => 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::ACSinglePhaseCore => "AC_single_phase_core",
            Self::ACThreePhaseCore => "AC_three_phase_core",
            Self::DCCore => "DC_core",
            Self::DCExtended => "DC_extended",
            Self::DCComboCore => "DC_combo_core",
            Self::DCUnique => "DC_unique",
        }
    }
}

/// The `choice of 2` alternatives of [`Entry`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum EntryChoice {
    /// `RelativeTimeInterval`
    RelativeTimeInterval(RelativeTimeInterval),
    /// `TimeInterval`
    TimeInterval(Interval),
}

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

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

impl Entry {
    /// 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 Entry {
    /// 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 {
                EntryChoice::RelativeTimeInterval(value) => {
                    w.start_branch(e, 0, 0, 0)?;
                    value.encode_body(e)?;
                }
                EntryChoice::TimeInterval(value) => {
                    w.start_branch(e, 0, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Entry {
    /// 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 = RelativeTimeInterval::decode_body(d)?;
                            EntryChoice::RelativeTimeInterval(value)
                        }
                        1 => {
                            let value = Interval::decode_body(d)?;
                            EntryChoice::TimeInterval(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)? })
    }
}

/// `IntervalType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Interval;

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

impl Interval {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Interval {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// `ListOfRootCertificateIDsType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ListOfRootCertificateIDs {
    /// `RootCertificateID` element, 1..20.
    pub root_certificate_id: Vec<X509IssuerSerial>,
}

impl ListOfRootCertificateIDs {
    /// 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: &[20] };
}

impl ListOfRootCertificateIDs {
    /// 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);
        // RootCertificateID (1..20)
        {
            let items = &self.root_certificate_id;
            let count = items.len() as u32;
            if count < 1 || count > 20 {
                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 ListOfRootCertificateIDs {
    /// 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 = X509IssuerSerial::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            root_certificate_id: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `ManifestType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Manifest {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `Reference` element, 1..unbounded.
    pub reference: Vec<Reference>,
}

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

impl Manifest {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(105), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // Reference (1..unbounded)
        {
            let items = &self.reference;
            let count = items.len() as u32;
            if count < 1 {
                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 Manifest {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(105), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = Reference::decode_body(d)?;
                    f_1.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            reference: {
                if (f_1.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_1
            },
        })
    }
}

/// `MessageHeaderType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MessageHeader {
    /// `SessionID` element, 1..1.
    pub session_id: Vec<u8>,
    /// `Notification` element, 0..1.
    pub notification: Option<Notification>,
    /// `Signature` element, 0..1.
    pub signature: Option<Signature>,
}

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

impl MessageHeader {
    /// 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);
        // SessionID (1..1)
        {
            let item = &self.session_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(8))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // Notification (0..1)
        if let Some(item) = &self.notification {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // Signature (0..1)
        if let Some(item) = &self.signature {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl MessageHeader {
    /// 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 = d.binary(Lengths::max(8))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = Notification::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = Signature::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            session_id: f_0.ok_or(ExiError::MissingElement)?,
            notification: f_1,
            signature: f_2,
        })
    }
}

/// `MeterInfoType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeterInfo {
    /// `MeterID` element, 1..1.
    pub meter_id: String,
    /// `MeterReading` element, 0..1.
    pub meter_reading: Option<u64>,
    /// `SigMeterReading` element, 0..1.
    pub sig_meter_reading: Option<Vec<u8>>,
    /// `MeterStatus` element, 0..1.
    pub meter_status: Option<i16>,
    /// `TMeter` element, 0..1.
    pub t_meter: Option<i64>,
}

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

impl MeterInfo {
    /// 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);
        // MeterID (1..1)
        {
            let item = &self.meter_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(111), item, Lengths::max(32))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // MeterReading (0..1)
        if let Some(item) = &self.meter_reading {
            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);
        }
        // SigMeterReading (0..1)
        if let Some(item) = &self.sig_meter_reading {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(64))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // MeterStatus (0..1)
        if let Some(item) = &self.meter_status {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // TMeter (0..1)
        if let Some(item) = &self.t_meter {
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl MeterInfo {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(111), Lengths::max(32))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u64::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 = d.binary(Lengths::max(64))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    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_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i64::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            meter_id: f_0.ok_or(ExiError::MissingElement)?,
            meter_reading: f_1,
            sig_meter_reading: f_2,
            meter_status: f_3,
            t_meter: f_4,
        })
    }
}

/// `MeteringReceiptReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeteringReceiptReq {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `SessionID` element, 1..1.
    pub session_id: Vec<u8>,
    /// `SAScheduleTupleID` element, 0..1.
    pub sa_schedule_tuple_id: Option<u8>,
    /// `MeterInfo` element, 1..1.
    pub meter_info: MeterInfo,
}

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

impl MeteringReceiptReq {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(106), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // SessionID (1..1)
        {
            let item = &self.session_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(8))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // SAScheduleTupleID (0..1)
        if let Some(item) = &self.sa_schedule_tuple_id {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // MeterInfo (1..1)
        {
            let item = &self.meter_info;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl MeteringReceiptReq {
    /// 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 = d.string(ValueCtx(106), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(8))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(1, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = MeterInfo::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            session_id: f_1.ok_or(ExiError::MissingElement)?,
            sa_schedule_tuple_id: f_2,
            meter_info: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 3` alternatives of [`MeteringReceiptRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MeteringReceiptResChoice {
    /// `AC_EVSEStatus`
    ACEVSEStatus(ACEVSEStatus),
    /// `DC_EVSEStatus`
    DCEVSEStatus(DCEVSEStatus),
    /// `EVSEStatus`
    EVSEStatus(EVSEStatus),
}

impl MeteringReceiptResChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::ACEVSEStatus(_) => "AC_EVSEStatus",
            Self::DCEVSEStatus(_) => "DC_EVSEStatus",
            Self::EVSEStatus(_) => "EVSEStatus",
        }
    }
}

/// `MeteringReceiptResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeteringReceiptRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `choice of 3` element, 1..1.
    pub choice: MeteringReceiptResChoice,
}

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

impl MeteringReceiptRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // choice of 3 (1..1)
        {
            let item = &self.choice;
            match item {
                MeteringReceiptResChoice::ACEVSEStatus(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    value.encode_body(e)?;
                }
                MeteringReceiptResChoice::DCEVSEStatus(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    value.encode_body(e)?;
                }
                MeteringReceiptResChoice::EVSEStatus(value) => {
                    w.start_branch(e, 1, 0, 2)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl MeteringReceiptRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = ACEVSEStatus::decode_body(d)?;
                            MeteringReceiptResChoice::ACEVSEStatus(value)
                        }
                        1 => {
                            let value = DCEVSEStatus::decode_body(d)?;
                            MeteringReceiptResChoice::DCEVSEStatus(value)
                        }
                        2 => {
                            let value = EVSEStatus::decode_body(d)?;
                            MeteringReceiptResChoice::EVSEStatus(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            choice: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `NotificationType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Notification {
    /// `FaultCode` element, 1..1.
    pub fault_code: FaultCode,
    /// `FaultMsg` element, 0..1.
    pub fault_msg: Option<String>,
}

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

impl Notification {
    /// 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);
        // FaultCode (1..1)
        {
            let item = &self.fault_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), FaultCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // FaultMsg (0..1)
        if let Some(item) = &self.fault_msg {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(100), item, Lengths::max(64))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Notification {
    /// 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 = FaultCode::from_index(d.nbit(FaultCode::WIDTH)?)?;
                    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(100), Lengths::max(64))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { fault_code: f_0.ok_or(ExiError::MissingElement)?, fault_msg: f_1 })
    }
}

/// The `choice of 2` alternatives of [`PMaxScheduleEntry`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PMaxScheduleEntryChoice {
    /// `RelativeTimeInterval`
    RelativeTimeInterval(RelativeTimeInterval),
    /// `TimeInterval`
    TimeInterval(Interval),
}

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

/// `PMaxScheduleEntryType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PMaxScheduleEntry {
    /// `choice of 2` element, 1..1.
    pub choice: PMaxScheduleEntryChoice,
    /// `PMax` element, 1..1.
    pub p_max: PhysicalValue,
}

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

impl PMaxScheduleEntry {
    /// 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 {
                PMaxScheduleEntryChoice::RelativeTimeInterval(value) => {
                    w.start_branch(e, 0, 0, 0)?;
                    value.encode_body(e)?;
                }
                PMaxScheduleEntryChoice::TimeInterval(value) => {
                    w.start_branch(e, 0, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(0, 1);
        }
        // PMax (1..1)
        {
            let item = &self.p_max;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PMaxScheduleEntry {
    /// 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, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = RelativeTimeInterval::decode_body(d)?;
                            PMaxScheduleEntryChoice::RelativeTimeInterval(value)
                        }
                        1 => {
                            let value = Interval::decode_body(d)?;
                            PMaxScheduleEntryChoice::TimeInterval(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            choice: f_0.ok_or(ExiError::MissingElement)?,
            p_max: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PMaxScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PMaxSchedule {
    /// `PMaxScheduleEntry` element, 1..1024.
    pub p_max_schedule_entry: Vec<PMaxScheduleEntry>,
}

impl PMaxSchedule {
    /// 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: &[1024] };
}

impl PMaxSchedule {
    /// 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);
        // PMaxScheduleEntry (1..1024)
        {
            let items = &self.p_max_schedule_entry;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                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 PMaxSchedule {
    /// 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 = PMaxScheduleEntry::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            p_max_schedule_entry: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `ParameterSetType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ParameterSet {
    /// `ParameterSetID` element, 1..1.
    pub parameter_set_id: i16,
    /// `Parameter` element, 1..16.
    pub parameter: Vec<Parameter>,
}

impl ParameterSet {
    /// 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, 1],
        max: &[1, 16],
    };
}

impl ParameterSet {
    /// 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);
        // ParameterSetID (1..1)
        {
            let item = &self.parameter_set_id;
            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);
        }
        // Parameter (1..16)
        {
            let items = &self.parameter;
            let count = items.len() as u32;
            if count < 1 || count > 16 {
                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 ParameterSet {
    /// 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 = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = Parameter::decode_body(d)?;
                    f_1.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            parameter_set_id: f_0.ok_or(ExiError::MissingElement)?,
            parameter: {
                if (f_1.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_1
            },
        })
    }
}

/// The `choice of 6` alternatives of [`Parameter`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ParameterChoice {
    /// `boolValue`
    BoolValue(bool),
    /// `byteValue`
    ByteValue(i8),
    /// `shortValue`
    ShortValue(i16),
    /// `intValue`
    IntValue(i32),
    /// `physicalValue`
    PhysicalValue(PhysicalValue),
    /// `stringValue`
    StringValue(String),
}

impl ParameterChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::BoolValue(_) => "boolValue",
            Self::ByteValue(_) => "byteValue",
            Self::ShortValue(_) => "shortValue",
            Self::IntValue(_) => "intValue",
            Self::PhysicalValue(_) => "physicalValue",
            Self::StringValue(_) => "stringValue",
        }
    }
}

/// `ParameterType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Parameter {
    /// `Name` attribute, 1..1.
    pub name: String,
    /// `choice of 6` element, 1..1.
    pub choice: ParameterChoice,
}

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

impl Parameter {
    /// 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);
        // Name (1..1)
        {
            let item = &self.name;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(119), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // choice of 6 (1..1)
        {
            let item = &self.choice;
            match item {
                ParameterChoice::BoolValue(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.boolean(*value)?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::ByteValue(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.restricted(i64::from(*value), -128, 127)?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::ShortValue(value) => {
                    w.start_branch(e, 1, 0, 2)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.int(i64::from(*value))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::IntValue(value) => {
                    w.start_branch(e, 1, 0, 3)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.int(i64::from(*value))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::PhysicalValue(value) => {
                    w.start_branch(e, 1, 0, 4)?;
                    value.encode_body(e)?;
                }
                ParameterChoice::StringValue(value) => {
                    w.start_branch(e, 1, 0, 5)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.string(ValueCtx(217), value, Lengths::max(65536))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Parameter {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(119), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.boolean()?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::BoolValue(value)
                        }
                        1 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = i8::try_from(d.restricted(-128, 127)?)
                                .map_err(|_| ExiError::ValueOutOfRange)?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::ByteValue(value)
                        }
                        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
                            ParameterChoice::ShortValue(value)
                        }
                        3 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value =
                                i32::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::IntValue(value)
                        }
                        4 => {
                            let value = PhysicalValue::decode_body(d)?;
                            ParameterChoice::PhysicalValue(value)
                        }
                        5 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.string(ValueCtx(217), Lengths::max(65536))?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::StringValue(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            name: f_0.ok_or(ExiError::MissingElement)?,
            choice: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PaymentDetailsReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PaymentDetailsReq {
    /// `eMAID` element, 1..1.
    pub e_maid: String,
    /// `ContractSignatureCertChain` element, 1..1.
    pub contract_signature_cert_chain: CertificateChain,
}

impl PaymentDetailsReq {
    /// 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 PaymentDetailsReq {
    /// 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);
        // eMAID (1..1)
        {
            let item = &self.e_maid;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(211), item, Lengths::new(14, 15))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // ContractSignatureCertChain (1..1)
        {
            let item = &self.contract_signature_cert_chain;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PaymentDetailsReq {
    /// 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 = d.string(ValueCtx(211), Lengths::new(14, 15))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            e_maid: f_0.ok_or(ExiError::MissingElement)?,
            contract_signature_cert_chain: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PaymentDetailsResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PaymentDetailsRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `GenChallenge` element, 1..1.
    pub gen_challenge: Vec<u8>,
    /// `EVSETimeStamp` element, 1..1.
    pub evse_time_stamp: i64,
}

impl PaymentDetailsRes {
    /// 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 PaymentDetailsRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // GenChallenge (1..1)
        {
            let item = &self.gen_challenge;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::exact(16))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSETimeStamp (1..1)
        {
            let item = &self.evse_time_stamp;
            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 PaymentDetailsRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    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.binary(Lengths::exact(16))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i64::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 {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            gen_challenge: f_1.ok_or(ExiError::MissingElement)?,
            evse_time_stamp: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PaymentOptionListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PaymentOptionList {
    /// `PaymentOption` element, 1..2.
    pub payment_option: Vec<PaymentOption>,
}

impl PaymentOptionList {
    /// 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: &[2] };
}

impl PaymentOptionList {
    /// 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);
        // PaymentOption (1..2)
        {
            let items = &self.payment_option;
            let count = items.len() as u32;
            if count < 1 || count > 2 {
                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(), PaymentOption::WIDTH)?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PaymentOptionList {
    /// 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 = PaymentOption::from_index(d.nbit(PaymentOption::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            payment_option: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `PaymentServiceSelectionReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PaymentServiceSelectionReq {
    /// `SelectedPaymentOption` element, 1..1.
    pub selected_payment_option: PaymentOption,
    /// `SelectedServiceList` element, 1..1.
    pub selected_service_list: SelectedServiceList,
}

impl PaymentServiceSelectionReq {
    /// 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 PaymentServiceSelectionReq {
    /// 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);
        // SelectedPaymentOption (1..1)
        {
            let item = &self.selected_payment_option;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), PaymentOption::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SelectedServiceList (1..1)
        {
            let item = &self.selected_service_list;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PaymentServiceSelectionReq {
    /// 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 = PaymentOption::from_index(d.nbit(PaymentOption::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = SelectedServiceList::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            selected_payment_option: f_0.ok_or(ExiError::MissingElement)?,
            selected_service_list: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PaymentServiceSelectionResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PaymentServiceSelectionRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
}

impl PaymentServiceSelectionRes {
    /// 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 PaymentServiceSelectionRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PaymentServiceSelectionRes {
    /// 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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { response_code: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `PhysicalValueType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PhysicalValue {
    /// `Multiplier` element, 1..1.
    pub multiplier: i8,
    /// `Unit` element, 1..1.
    pub unit: UnitSymbol,
    /// `Value` element, 1..1.
    pub value: i16,
}

impl PhysicalValue {
    /// 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 PhysicalValue {
    /// 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);
        // Multiplier (1..1)
        {
            let item = &self.multiplier;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), -3, 3)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // Unit (1..1)
        {
            let item = &self.unit;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), UnitSymbol::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // Value (1..1)
        {
            let item = &self.value;
            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 PhysicalValue {
    /// 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 = i8::try_from(d.restricted(-3, 3)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = UnitSymbol::from_index(d.nbit(UnitSymbol::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 = 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 {
            multiplier: f_0.ok_or(ExiError::MissingElement)?,
            unit: f_1.ok_or(ExiError::MissingElement)?,
            value: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`PowerDeliveryReq`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PowerDeliveryReqChoice {
    /// `DC_EVPowerDeliveryParameter`
    DCEVPowerDeliveryParameter(DCEVPowerDeliveryParameter),
    /// `EVPowerDeliveryParameter`
    EVPowerDeliveryParameter(EVPowerDeliveryParameter),
}

impl PowerDeliveryReqChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::DCEVPowerDeliveryParameter(_) => "DC_EVPowerDeliveryParameter",
            Self::EVPowerDeliveryParameter(_) => "EVPowerDeliveryParameter",
        }
    }
}

/// `PowerDeliveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerDeliveryReq {
    /// `ChargeProgress` element, 1..1.
    pub charge_progress: ChargeProgress,
    /// `SAScheduleTupleID` element, 1..1.
    pub sa_schedule_tuple_id: u8,
    /// `ChargingProfile` element, 0..1.
    pub charging_profile: Option<ChargingProfile>,
    /// `choice of 2` element, 0..1.
    pub choice: Option<PowerDeliveryReqChoice>,
}

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

impl PowerDeliveryReq {
    /// 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);
        // ChargeProgress (1..1)
        {
            let item = &self.charge_progress;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ChargeProgress::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SAScheduleTupleID (1..1)
        {
            let item = &self.sa_schedule_tuple_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ChargingProfile (0..1)
        if let Some(item) = &self.charging_profile {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // choice of 2 (0..1)
        if let Some(item) = &self.choice {
            match item {
                PowerDeliveryReqChoice::DCEVPowerDeliveryParameter(value) => {
                    w.start_branch(e, 3, 0, 0)?;
                    value.encode_body(e)?;
                }
                PowerDeliveryReqChoice::EVPowerDeliveryParameter(value) => {
                    w.start_branch(e, 3, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PowerDeliveryReq {
    /// 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 = ChargeProgress::from_index(d.nbit(ChargeProgress::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(1, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = ChargingProfile::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = DCEVPowerDeliveryParameter::decode_body(d)?;
                            PowerDeliveryReqChoice::DCEVPowerDeliveryParameter(value)
                        }
                        1 => {
                            let value = EVPowerDeliveryParameter::decode_body(d)?;
                            PowerDeliveryReqChoice::EVPowerDeliveryParameter(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            charge_progress: f_0.ok_or(ExiError::MissingElement)?,
            sa_schedule_tuple_id: f_1.ok_or(ExiError::MissingElement)?,
            charging_profile: f_2,
            choice: f_3,
        })
    }
}

/// The `choice of 3` alternatives of [`PowerDeliveryRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PowerDeliveryResChoice {
    /// `AC_EVSEStatus`
    ACEVSEStatus(ACEVSEStatus),
    /// `DC_EVSEStatus`
    DCEVSEStatus(DCEVSEStatus),
    /// `EVSEStatus`
    EVSEStatus(EVSEStatus),
}

impl PowerDeliveryResChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::ACEVSEStatus(_) => "AC_EVSEStatus",
            Self::DCEVSEStatus(_) => "DC_EVSEStatus",
            Self::EVSEStatus(_) => "EVSEStatus",
        }
    }
}

/// `PowerDeliveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerDeliveryRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `choice of 3` element, 1..1.
    pub choice: PowerDeliveryResChoice,
}

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

impl PowerDeliveryRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // choice of 3 (1..1)
        {
            let item = &self.choice;
            match item {
                PowerDeliveryResChoice::ACEVSEStatus(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    value.encode_body(e)?;
                }
                PowerDeliveryResChoice::DCEVSEStatus(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    value.encode_body(e)?;
                }
                PowerDeliveryResChoice::EVSEStatus(value) => {
                    w.start_branch(e, 1, 0, 2)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PowerDeliveryRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = ACEVSEStatus::decode_body(d)?;
                            PowerDeliveryResChoice::ACEVSEStatus(value)
                        }
                        1 => {
                            let value = DCEVSEStatus::decode_body(d)?;
                            PowerDeliveryResChoice::DCEVSEStatus(value)
                        }
                        2 => {
                            let value = EVSEStatus::decode_body(d)?;
                            PowerDeliveryResChoice::EVSEStatus(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            choice: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PreChargeReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PreChargeReq {
    /// `DC_EVStatus` element, 1..1.
    pub dc_ev_status: DCEVStatus,
    /// `EVTargetVoltage` element, 1..1.
    pub ev_target_voltage: PhysicalValue,
    /// `EVTargetCurrent` element, 1..1.
    pub ev_target_current: PhysicalValue,
}

impl PreChargeReq {
    /// 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 PreChargeReq {
    /// 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);
        // DC_EVStatus (1..1)
        {
            let item = &self.dc_ev_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVTargetVoltage (1..1)
        {
            let item = &self.ev_target_voltage;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVTargetCurrent (1..1)
        {
            let item = &self.ev_target_current;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PreChargeReq {
    /// 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, .. } => {
                    let value = DCEVStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            dc_ev_status: f_0.ok_or(ExiError::MissingElement)?,
            ev_target_voltage: f_1.ok_or(ExiError::MissingElement)?,
            ev_target_current: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PreChargeResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PreChargeRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `DC_EVSEStatus` element, 1..1.
    pub dc_evse_status: DCEVSEStatus,
    /// `EVSEPresentVoltage` element, 1..1.
    pub evse_present_voltage: PhysicalValue,
}

impl PreChargeRes {
    /// 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 PreChargeRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // DC_EVSEStatus (1..1)
        {
            let item = &self.dc_evse_status;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEPresentVoltage (1..1)
        {
            let item = &self.evse_present_voltage;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PreChargeRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = DCEVSEStatus::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            dc_evse_status: f_1.ok_or(ExiError::MissingElement)?,
            evse_present_voltage: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ProfileEntryType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ProfileEntry {
    /// `ChargingProfileEntryStart` element, 1..1.
    pub charging_profile_entry_start: u32,
    /// `ChargingProfileEntryMaxPower` element, 1..1.
    pub charging_profile_entry_max_power: PhysicalValue,
    /// `ChargingProfileEntryMaxNumberOfPhasesInUse` element, 0..1.
    pub charging_profile_entry_max_number_of_phases_in_use: Option<u8>,
}

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

impl ProfileEntry {
    /// 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);
        // ChargingProfileEntryStart (1..1)
        {
            let item = &self.charging_profile_entry_start;
            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);
        }
        // ChargingProfileEntryMaxPower (1..1)
        {
            let item = &self.charging_profile_entry_max_power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ChargingProfileEntryMaxNumberOfPhasesInUse (0..1)
        if let Some(item) = &self.charging_profile_entry_max_number_of_phases_in_use {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 3)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ProfileEntry {
    /// 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 = PhysicalValue::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value =
                        u8::try_from(d.restricted(1, 3)?).map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            charging_profile_entry_start: f_0.ok_or(ExiError::MissingElement)?,
            charging_profile_entry_max_power: f_1.ok_or(ExiError::MissingElement)?,
            charging_profile_entry_max_number_of_phases_in_use: f_2,
        })
    }
}

/// `RSAKeyValueType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RSAKeyValue {
    /// `Modulus` element, 1..1.
    pub modulus: Vec<u8>,
    /// `Exponent` element, 1..1.
    pub exponent: Vec<u8>,
}

impl RSAKeyValue {
    /// 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 RSAKeyValue {
    /// 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);
        // Modulus (1..1)
        {
            let item = &self.modulus;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(65536))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // Exponent (1..1)
        {
            let item = &self.exponent;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(65536))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl RSAKeyValue {
    /// 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 = d.binary(Lengths::max(65536))?;
                    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.binary(Lengths::max(65536))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            modulus: f_0.ok_or(ExiError::MissingElement)?,
            exponent: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ReferenceType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Reference {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `Type` attribute, 0..1.
    pub r#type: Option<String>,
    /// `URI` attribute, 0..1.
    pub uri: Option<String>,
    /// `Transforms` element, 0..1.
    pub transforms: Option<Transforms>,
    /// `DigestMethod` element, 1..1.
    pub digest_method: DigestMethod,
    /// `DigestValue` element, 1..1.
    pub digest_value: Vec<u8>,
}

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

impl Reference {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(105), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // Type (0..1)
        if let Some(item) = &self.r#type {
            w.start(e, 1, 0)?;
            e.string(ValueCtx(196), item, Lengths::max(65536))?;
            w.finish(1, 1);
        }
        // URI (0..1)
        if let Some(item) = &self.uri {
            w.start(e, 2, 0)?;
            e.string(ValueCtx(197), item, Lengths::max(65536))?;
            w.finish(2, 1);
        }
        // Transforms (0..1)
        if let Some(item) = &self.transforms {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // DigestMethod (1..1)
        {
            let item = &self.digest_method;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // DigestValue (1..1)
        {
            let item = &self.digest_value;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(65536))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Reference {
    /// 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = d.string(ValueCtx(105), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.string(ValueCtx(196), Lengths::max(65536))?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = d.string(ValueCtx(197), Lengths::max(65536))?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = Transforms::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = DigestMethod::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(65536))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            r#type: f_1,
            uri: f_2,
            transforms: f_3,
            digest_method: f_4.ok_or(ExiError::MissingElement)?,
            digest_value: f_5.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `RelativeTimeIntervalType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RelativeTimeInterval {
    /// `start` element, 1..1.
    pub start: u32,
    /// `duration` element, 0..1.
    pub duration: Option<u32>,
}

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

impl RelativeTimeInterval {
    /// 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);
        // start (1..1)
        {
            let item = &self.start;
            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);
        }
        // duration (0..1)
        if let Some(item) = &self.duration {
            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 RelativeTimeInterval {
    /// 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, .. } => {
                    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 { start: f_0.ok_or(ExiError::MissingElement)?, duration: f_1 })
    }
}

/// `RetrievalMethodType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RetrievalMethod {
    /// `Type` attribute, 0..1.
    pub r#type: Option<String>,
    /// `URI` attribute, 0..1.
    pub uri: Option<String>,
    /// `Transforms` element, 0..1.
    pub transforms: Option<Transforms>,
}

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

impl RetrievalMethod {
    /// 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);
        // Type (0..1)
        if let Some(item) = &self.r#type {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(196), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // URI (0..1)
        if let Some(item) = &self.uri {
            w.start(e, 1, 0)?;
            e.string(ValueCtx(197), item, Lengths::max(65536))?;
            w.finish(1, 1);
        }
        // Transforms (0..1)
        if let Some(item) = &self.transforms {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl RetrievalMethod {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(196), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.string(ValueCtx(197), Lengths::max(65536))?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = Transforms::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { r#type: f_0, uri: f_1, transforms: f_2 })
    }
}

/// `SAScheduleListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SAScheduleList {
    /// `SAScheduleTuple` element, 1..3.
    pub sa_schedule_tuple: Vec<SAScheduleTuple>,
}

impl SAScheduleList {
    /// 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: &[3] };
}

impl SAScheduleList {
    /// 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);
        // SAScheduleTuple (1..3)
        {
            let items = &self.sa_schedule_tuple;
            let count = items.len() as u32;
            if count < 1 || count > 3 {
                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 SAScheduleList {
    /// 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 = SAScheduleTuple::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            sa_schedule_tuple: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `SAScheduleTupleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SAScheduleTuple {
    /// `SAScheduleTupleID` element, 1..1.
    pub sa_schedule_tuple_id: u8,
    /// `PMaxSchedule` element, 1..1.
    pub p_max_schedule: PMaxSchedule,
    /// `SalesTariff` element, 0..1.
    pub sales_tariff: Option<SalesTariff>,
}

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

impl SAScheduleTuple {
    /// 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);
        // SAScheduleTupleID (1..1)
        {
            let item = &self.sa_schedule_tuple_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // PMaxSchedule (1..1)
        {
            let item = &self.p_max_schedule;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // SalesTariff (0..1)
        if let Some(item) = &self.sales_tariff {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SAScheduleTuple {
    /// 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 = u8::try_from(d.restricted(1, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PMaxSchedule::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = SalesTariff::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            sa_schedule_tuple_id: f_0.ok_or(ExiError::MissingElement)?,
            p_max_schedule: f_1.ok_or(ExiError::MissingElement)?,
            sales_tariff: f_2,
        })
    }
}

/// `SASchedulesType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SASchedules;

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

impl SASchedules {
    /// 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);
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SASchedules {
    /// 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);
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {})
    }
}

/// The `choice of 2` alternatives of [`SalesTariffEntry`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SalesTariffEntryChoice {
    /// `RelativeTimeInterval`
    RelativeTimeInterval(RelativeTimeInterval),
    /// `TimeInterval`
    TimeInterval(Interval),
}

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

/// `SalesTariffEntryType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SalesTariffEntry {
    /// `choice of 2` element, 1..1.
    pub choice: SalesTariffEntryChoice,
    /// `EPriceLevel` element, 0..1.
    pub e_price_level: Option<u8>,
    /// `ConsumptionCost` element, 0..3.
    pub consumption_cost: Vec<ConsumptionCost>,
}

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

impl SalesTariffEntry {
    /// 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 {
                SalesTariffEntryChoice::RelativeTimeInterval(value) => {
                    w.start_branch(e, 0, 0, 0)?;
                    value.encode_body(e)?;
                }
                SalesTariffEntryChoice::TimeInterval(value) => {
                    w.start_branch(e, 0, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(0, 1);
        }
        // EPriceLevel (0..1)
        if let Some(item) = &self.e_price_level {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ConsumptionCost (0..3)
        {
            let items = &self.consumption_cost;
            let count = items.len() as u32;
            if count > 3 {
                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);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SalesTariffEntry {
    /// 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();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = RelativeTimeInterval::decode_body(d)?;
                            SalesTariffEntryChoice::RelativeTimeInterval(value)
                        }
                        1 => {
                            let value = Interval::decode_body(d)?;
                            SalesTariffEntryChoice::TimeInterval(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    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_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = ConsumptionCost::decode_body(d)?;
                    f_2.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            choice: f_0.ok_or(ExiError::MissingElement)?,
            e_price_level: f_1,
            consumption_cost: f_2,
        })
    }
}

/// `SalesTariffType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SalesTariff {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `SalesTariffID` element, 1..1.
    pub sales_tariff_id: u8,
    /// `SalesTariffDescription` element, 0..1.
    pub sales_tariff_description: Option<String>,
    /// `NumEPriceLevels` element, 0..1.
    pub num_e_price_levels: Option<u8>,
    /// `SalesTariffEntry` element, 1..1024.
    pub sales_tariff_entry: Vec<SalesTariffEntry>,
}

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

impl SalesTariff {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(107), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // SalesTariffID (1..1)
        {
            let item = &self.sales_tariff_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 1, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // SalesTariffDescription (0..1)
        if let Some(item) = &self.sales_tariff_description {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(159), item, Lengths::max(32))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // NumEPriceLevels (0..1)
        if let Some(item) = &self.num_e_price_levels {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // SalesTariffEntry (1..1024)
        {
            let items = &self.sales_tariff_entry;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 4, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(4, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SalesTariff {
    /// 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 = d.string(ValueCtx(107), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(1, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    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(159), Lengths::max(32))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    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_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = SalesTariffEntry::decode_body(d)?;
                    f_4.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            sales_tariff_id: f_1.ok_or(ExiError::MissingElement)?,
            sales_tariff_description: f_2,
            num_e_price_levels: f_3,
            sales_tariff_entry: {
                if (f_4.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_4
            },
        })
    }
}

/// `SelectedServiceListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SelectedServiceList {
    /// `SelectedService` element, 1..16.
    pub selected_service: Vec<SelectedService>,
}

impl SelectedServiceList {
    /// 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: &[16] };
}

impl SelectedServiceList {
    /// 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);
        // SelectedService (1..16)
        {
            let items = &self.selected_service;
            let count = items.len() as u32;
            if count < 1 || count > 16 {
                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 SelectedServiceList {
    /// 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 = SelectedService::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            selected_service: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `SelectedServiceType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SelectedService {
    /// `ServiceID` element, 1..1.
    pub service_id: u16,
    /// `ParameterSetID` element, 0..1.
    pub parameter_set_id: Option<i16>,
}

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

impl SelectedService {
    /// 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);
        // ServiceID (1..1)
        {
            let item = &self.service_id;
            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);
        }
        // ParameterSetID (0..1)
        if let Some(item) = &self.parameter_set_id {
            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);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SelectedService {
    /// 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 = i16::try_from(d.int()?).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 { service_id: f_0.ok_or(ExiError::MissingElement)?, parameter_set_id: f_1 })
    }
}

/// `ServiceDetailReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceDetailReq {
    /// `ServiceID` element, 1..1.
    pub service_id: u16,
}

impl ServiceDetailReq {
    /// 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 ServiceDetailReq {
    /// 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);
        // ServiceID (1..1)
        {
            let item = &self.service_id;
            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);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ServiceDetailReq {
    /// 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, .. } => {
                    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 { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { service_id: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `ServiceDetailResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceDetailRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `ServiceID` element, 1..1.
    pub service_id: u16,
    /// `ServiceParameterList` element, 0..1.
    pub service_parameter_list: Option<ServiceParameterList>,
}

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

impl ServiceDetailRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // ServiceID (1..1)
        {
            let item = &self.service_id;
            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);
        }
        // ServiceParameterList (0..1)
        if let Some(item) = &self.service_parameter_list {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ServiceDetailRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(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, .. } => {
                    let value = ServiceParameterList::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            service_id: f_1.ok_or(ExiError::MissingElement)?,
            service_parameter_list: f_2,
        })
    }
}

/// `ServiceDiscoveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceDiscoveryReq {
    /// `ServiceScope` element, 0..1.
    pub service_scope: Option<String>,
    /// `ServiceCategory` element, 0..1.
    pub service_category: Option<ServiceCategory>,
}

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

impl ServiceDiscoveryReq {
    /// 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);
        // ServiceScope (0..1)
        if let Some(item) = &self.service_scope {
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(177), item, Lengths::max(64))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // ServiceCategory (0..1)
        if let Some(item) = &self.service_category {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ServiceCategory::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ServiceDiscoveryReq {
    /// 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 = d.string(ValueCtx(177), Lengths::max(64))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ServiceCategory::from_index(d.nbit(ServiceCategory::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { service_scope: f_0, service_category: f_1 })
    }
}

/// `ServiceDiscoveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceDiscoveryRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `PaymentOptionList` element, 1..1.
    pub payment_option_list: PaymentOptionList,
    /// `ChargeService` element, 1..1.
    pub charge_service: ChargeService,
    /// `ServiceList` element, 0..1.
    pub service_list: Option<ServiceList>,
}

impl ServiceDiscoveryRes {
    /// 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, 0, 0],
        min: &[1, 1, 1, 0],
        max: &[1, 1, 1, 1],
    };
}

impl ServiceDiscoveryRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // PaymentOptionList (1..1)
        {
            let item = &self.payment_option_list;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ChargeService (1..1)
        {
            let item = &self.charge_service;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // ServiceList (0..1)
        if let Some(item) = &self.service_list {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ServiceDiscoveryRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = PaymentOptionList::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = ChargeService::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = ServiceList::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            payment_option_list: f_1.ok_or(ExiError::MissingElement)?,
            charge_service: f_2.ok_or(ExiError::MissingElement)?,
            service_list: f_3,
        })
    }
}

/// `ServiceListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceList {
    /// `Service` element, 1..8.
    pub service: Vec<Service>,
}

impl ServiceList {
    /// 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 ServiceList {
    /// 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);
        // Service (1..8)
        {
            let items = &self.service;
            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 ServiceList {
    /// 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 = Service::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            service: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `ServiceParameterListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceParameterList {
    /// `ParameterSet` element, 1..255.
    pub parameter_set: Vec<ParameterSet>,
}

impl ServiceParameterList {
    /// 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: &[255] };
}

impl ServiceParameterList {
    /// 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);
        // ParameterSet (1..255)
        {
            let items = &self.parameter_set;
            let count = items.len() as u32;
            if count < 1 || 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);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ServiceParameterList {
    /// 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 = ParameterSet::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            parameter_set: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `ServiceType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Service {
    /// `ServiceID` element, 1..1.
    pub service_id: u16,
    /// `ServiceName` element, 0..1.
    pub service_name: Option<String>,
    /// `ServiceCategory` element, 1..1.
    pub service_category: ServiceCategory,
    /// `ServiceScope` element, 0..1.
    pub service_scope: Option<String>,
    /// `FreeService` element, 1..1.
    pub free_service: bool,
}

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

impl Service {
    /// 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);
        // ServiceID (1..1)
        {
            let item = &self.service_id;
            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);
        }
        // ServiceName (0..1)
        if let Some(item) = &self.service_name {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(175), item, Lengths::max(32))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ServiceCategory (1..1)
        {
            let item = &self.service_category;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ServiceCategory::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // ServiceScope (0..1)
        if let Some(item) = &self.service_scope {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(178), item, Lengths::max(64))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // FreeService (1..1)
        {
            let item = &self.free_service;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Service {
    /// 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;
        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 = d.string(ValueCtx(175), Lengths::max(32))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ServiceCategory::from_index(d.nbit(ServiceCategory::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.string(ValueCtx(178), Lengths::max(64))?;
                    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.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            service_id: f_0.ok_or(ExiError::MissingElement)?,
            service_name: f_1,
            service_category: f_2.ok_or(ExiError::MissingElement)?,
            service_scope: f_3,
            free_service: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `SessionSetupReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SessionSetupReq {
    /// `EVCCID` element, 1..1.
    pub evcc_id: Vec<u8>,
}

impl SessionSetupReq {
    /// 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 SessionSetupReq {
    /// 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);
        // EVCCID (1..1)
        {
            let item = &self.evcc_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(6))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SessionSetupReq {
    /// 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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(6))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { evcc_id: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `SessionSetupResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SessionSetupRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `EVSEID` element, 1..1.
    pub evse_id: String,
    /// `EVSETimeStamp` element, 0..1.
    pub evse_time_stamp: Option<i64>,
}

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

impl SessionSetupRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EVSEID (1..1)
        {
            let item = &self.evse_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(72), item, Lengths::new(7, 37))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSETimeStamp (0..1)
        if let Some(item) = &self.evse_time_stamp {
            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 SessionSetupRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    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(72), Lengths::new(7, 37))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i64::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 {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            evse_id: f_1.ok_or(ExiError::MissingElement)?,
            evse_time_stamp: f_2,
        })
    }
}

/// `SessionStopReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SessionStopReq {
    /// `ChargingSession` element, 1..1.
    pub charging_session: ChargingSession,
}

impl SessionStopReq {
    /// 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 SessionStopReq {
    /// 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);
        // ChargingSession (1..1)
        {
            let item = &self.charging_session;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ChargingSession::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SessionStopReq {
    /// 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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ChargingSession::from_index(d.nbit(ChargingSession::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { charging_session: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `SessionStopResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SessionStopRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
}

impl SessionStopRes {
    /// 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 SessionStopRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SessionStopRes {
    /// 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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { response_code: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `SignatureMethodType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignatureMethod {
    /// `Algorithm` attribute, 1..1.
    pub algorithm: String,
    /// `HMACOutputLength` element, 0..1.
    pub hmac_output_length: Option<i64>,
    // `xs:any wildcard` is not modelled: its type needs XML signature machinery this
    // crate does not implement. Decoding one is refused.
}

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

impl SignatureMethod {
    /// 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);
        // Algorithm (1..1)
        {
            let item = &self.algorithm;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(4), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // HMACOutputLength (0..1)
        if let Some(item) = &self.hmac_output_length {
            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);
        }
        // xs:any wildcard is never written.
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SignatureMethod {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(4), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i64::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                // `xs:any wildcard` is refused, not skipped.
                Step::Item { index: 2, .. } => return Err(ExiError::UnsupportedOption),
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { algorithm: f_0.ok_or(ExiError::MissingElement)?, hmac_output_length: f_1 })
    }
}

/// `SignatureType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Signature {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `SignedInfo` element, 1..1.
    pub signed_info: SignedInfo,
    /// `SignatureValue` element, 1..1.
    pub signature_value: SignatureValue,
    // `KeyInfo` is not modelled: its type needs XML signature machinery this
    // crate does not implement. Decoding one is refused.
    // `Object` is not modelled: its type needs XML signature machinery this
    // crate does not implement. Decoding one is refused.
}

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

impl Signature {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(105), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // SignedInfo (1..1)
        {
            let item = &self.signed_info;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // SignatureValue (1..1)
        {
            let item = &self.signature_value;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // KeyInfo is never written.
        // Object is never written.
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Signature {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(105), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = SignedInfo::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = SignatureValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                // `KeyInfo` is refused, not skipped.
                Step::Item { index: 3, .. } => return Err(ExiError::UnsupportedOption),
                // `Object` is refused, not skipped.
                Step::Item { index: 4, .. } => return Err(ExiError::UnsupportedOption),
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            signed_info: f_1.ok_or(ExiError::MissingElement)?,
            signature_value: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `SignatureValueType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignatureValue {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `character data` attribute, 1..1.
    pub value: Vec<u8>,
}

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

impl SignatureValue {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(105), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // character data (1..1)
        {
            let item = &self.value;
            w.start(e, 1, 0)?;
            e.binary(item, Lengths::max(65536))?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SignatureValue {
    /// 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, .. } => {
                    let value = d.string(ValueCtx(105), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.binary(Lengths::max(65536))?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { id: f_0, value: f_1.ok_or(ExiError::MissingElement)? })
    }
}

/// `SignedInfoType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignedInfo {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `CanonicalizationMethod` element, 1..1.
    pub canonicalization_method: CanonicalizationMethod,
    /// `SignatureMethod` element, 1..1.
    pub signature_method: SignatureMethod,
    /// `Reference` element, 1..unbounded.
    pub reference: Vec<Reference>,
}

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

impl SignedInfo {
    /// 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);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(105), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // CanonicalizationMethod (1..1)
        {
            let item = &self.canonicalization_method;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // SignatureMethod (1..1)
        {
            let item = &self.signature_method;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // Reference (1..unbounded)
        {
            let items = &self.reference;
            let count = items.len() as u32;
            if count < 1 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 3, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(3, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SignedInfo {
    /// 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();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = d.string(ValueCtx(105), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = CanonicalizationMethod::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = SignatureMethod::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = Reference::decode_body(d)?;
                    f_3.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            canonicalization_method: f_1.ok_or(ExiError::MissingElement)?,
            signature_method: f_2.ok_or(ExiError::MissingElement)?,
            reference: {
                if (f_3.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_3
            },
        })
    }
}

/// `SubCertificatesType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SubCertificates {
    /// `Certificate` element, 1..4.
    pub certificate: Vec<Vec<u8>>,
}

impl SubCertificates {
    /// 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: &[4] };
}

impl SubCertificates {
    /// 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);
        // Certificate (1..4)
        {
            let items = &self.certificate;
            let count = items.len() as u32;
            if count < 1 || count > 4 {
                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.binary(item, Lengths::max(800))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SubCertificates {
    /// 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 = d.binary(Lengths::max(800))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            certificate: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `SupportedEnergyTransferModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SupportedEnergyTransferMode {
    /// `EnergyTransferMode` element, 1..6.
    pub energy_transfer_mode: Vec<EnergyTransferMode>,
}

impl SupportedEnergyTransferMode {
    /// 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: &[6] };
}

impl SupportedEnergyTransferMode {
    /// 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);
        // EnergyTransferMode (1..6)
        {
            let items = &self.energy_transfer_mode;
            let count = items.len() as u32;
            if count < 1 || count > 6 {
                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(), EnergyTransferMode::WIDTH)?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SupportedEnergyTransferMode {
    /// 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 = EnergyTransferMode::from_index(d.nbit(EnergyTransferMode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            energy_transfer_mode: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `TransformType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Transform {
    /// `Algorithm` attribute, 1..1.
    pub algorithm: String,
    // `choice of 2` is not modelled: its type needs XML signature machinery this
    // crate does not implement. Decoding one is refused.
}

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

impl Transform {
    /// 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);
        // Algorithm (1..1)
        {
            let item = &self.algorithm;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(4), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // choice of 2 is never written.
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Transform {
    /// 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 = d.string(ValueCtx(4), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                // `choice of 2` is refused, not skipped.
                Step::Item { index: 1, .. } => return Err(ExiError::UnsupportedOption),
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { algorithm: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `TransformsType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Transforms {
    /// `Transform` element, 1..unbounded.
    pub transform: Vec<Transform>,
}

impl Transforms {
    /// 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: &[4294967295],
    };
}

impl Transforms {
    /// 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);
        // Transform (1..unbounded)
        {
            let items = &self.transform;
            let count = items.len() as u32;
            if count < 1 {
                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 Transforms {
    /// 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 = Transform::decode_body(d)?;
                    f_0.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            transform: {
                if (f_0.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_0
            },
        })
    }
}

/// `WeldingDetectionReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WeldingDetectionReq {
    /// `DC_EVStatus` element, 1..1.
    pub dc_ev_status: DCEVStatus,
}

impl WeldingDetectionReq {
    /// 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 WeldingDetectionReq {
    /// 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);
        // DC_EVStatus (1..1)
        {
            let item = &self.dc_ev_status;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WeldingDetectionReq {
    /// 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 = DCEVStatus::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { dc_ev_status: f_0.ok_or(ExiError::MissingElement)? })
    }
}

/// `WeldingDetectionResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WeldingDetectionRes {
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `DC_EVSEStatus` element, 1..1.
    pub dc_evse_status: DCEVSEStatus,
    /// `EVSEPresentVoltage` element, 1..1.
    pub evse_present_voltage: PhysicalValue,
}

impl WeldingDetectionRes {
    /// 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 WeldingDetectionRes {
    /// 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);
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // DC_EVSEStatus (1..1)
        {
            let item = &self.dc_evse_status;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEPresentVoltage (1..1)
        {
            let item = &self.evse_present_voltage;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl WeldingDetectionRes {
    /// 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 = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = DCEVSEStatus::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = PhysicalValue::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            response_code: f_0.ok_or(ExiError::MissingElement)?,
            dc_evse_status: f_1.ok_or(ExiError::MissingElement)?,
            evse_present_voltage: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `X509IssuerSerialType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct X509IssuerSerial {
    /// `X509IssuerName` element, 1..1.
    pub x509_issuer_name: String,
    /// `X509SerialNumber` element, 1..1.
    pub x509_serial_number: i64,
}

impl X509IssuerSerial {
    /// 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 X509IssuerSerial {
    /// 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);
        // X509IssuerName (1..1)
        {
            let item = &self.x509_issuer_name;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(202), item, Lengths::max(65536))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // X509SerialNumber (1..1)
        {
            let item = &self.x509_serial_number;
            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);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl X509IssuerSerial {
    /// 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 = d.string(ValueCtx(202), Lengths::max(65536))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i64::try_from(d.int()?).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 {
            x509_issuer_name: f_0.ok_or(ExiError::MissingElement)?,
            x509_serial_number: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `chargeProgressType`.
///
/// 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 ChargeProgress {
    /// `Start`
    Start = 0,
    /// `Stop`
    Stop = 1,
    /// `Renegotiate`
    Renegotiate = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::Start, Self::Stop, Self::Renegotiate];

    /// 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::Start,
            1 => Self::Stop,
            2 => Self::Renegotiate,
            _ => 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::Start => "Start",
            Self::Stop => "Stop",
            Self::Renegotiate => "Renegotiate",
        }
    }
}

/// `chargingSessionType`.
///
/// 2 values, so 1 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 ChargingSession {
    /// `Terminate`
    Terminate = 0,
    /// `Pause`
    Pause = 1,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 2] = [Self::Terminate, Self::Pause];

    /// 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::Terminate,
            1 => Self::Pause,
            _ => 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::Terminate => "Terminate",
            Self::Pause => "Pause",
        }
    }
}

/// `costKindType`.
///
/// 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 CostKind {
    /// `relativePricePercentage`
    RelativePricePercentage = 0,
    /// `RenewableGenerationPercentage`
    RenewableGenerationPercentage = 1,
    /// `CarbonDioxideEmission`
    CarbonDioxideEmission = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [
        Self::RelativePricePercentage,
        Self::RenewableGenerationPercentage,
        Self::CarbonDioxideEmission,
    ];

    /// 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::RelativePricePercentage,
            1 => Self::RenewableGenerationPercentage,
            2 => Self::CarbonDioxideEmission,
            _ => 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::RelativePricePercentage => "relativePricePercentage",
            Self::RenewableGenerationPercentage => "RenewableGenerationPercentage",
            Self::CarbonDioxideEmission => "CarbonDioxideEmission",
        }
    }
}

/// `faultCodeType`.
///
/// 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 FaultCode {
    /// `ParsingError`
    ParsingError = 0,
    /// `NoTLSRootCertificatAvailable`
    NoTLSRootCertificatAvailable = 1,
    /// `UnknownError`
    UnknownError = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] =
        [Self::ParsingError, Self::NoTLSRootCertificatAvailable, Self::UnknownError];

    /// 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::ParsingError,
            1 => Self::NoTLSRootCertificatAvailable,
            2 => Self::UnknownError,
            _ => 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::ParsingError => "ParsingError",
            Self::NoTLSRootCertificatAvailable => "NoTLSRootCertificatAvailable",
            Self::UnknownError => "UnknownError",
        }
    }
}

/// `isolationLevelType`.
///
/// 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 IsolationLevel {
    /// `Invalid`
    Invalid = 0,
    /// `Valid`
    Valid = 1,
    /// `Warning`
    Warning = 2,
    /// `Fault`
    Fault = 3,
    /// `No_IMD`
    NoIMD = 4,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 5] =
        [Self::Invalid, Self::Valid, Self::Warning, Self::Fault, Self::NoIMD];

    /// 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::Invalid,
            1 => Self::Valid,
            2 => Self::Warning,
            3 => Self::Fault,
            4 => Self::NoIMD,
            _ => 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::Invalid => "Invalid",
            Self::Valid => "Valid",
            Self::Warning => "Warning",
            Self::Fault => "Fault",
            Self::NoIMD => "No_IMD",
        }
    }
}

/// `paymentOptionType`.
///
/// 2 values, so 1 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 PaymentOption {
    /// `Contract`
    Contract = 0,
    /// `ExternalPayment`
    ExternalPayment = 1,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 2] = [Self::Contract, Self::ExternalPayment];

    /// 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::Contract,
            1 => Self::ExternalPayment,
            _ => 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::Contract => "Contract",
            Self::ExternalPayment => "ExternalPayment",
        }
    }
}

/// `responseCodeType`.
///
/// 26 values, so 5 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 ResponseCode {
    /// `OK`
    OK = 0,
    /// `OK_NewSessionEstablished`
    OKNewSessionEstablished = 1,
    /// `OK_OldSessionJoined`
    OKOldSessionJoined = 2,
    /// `OK_CertificateExpiresSoon`
    OKCertificateExpiresSoon = 3,
    /// `FAILED`
    FAILED = 4,
    /// `FAILED_SequenceError`
    FAILEDSequenceError = 5,
    /// `FAILED_ServiceIDInvalid`
    FAILEDServiceIDInvalid = 6,
    /// `FAILED_UnknownSession`
    FAILEDUnknownSession = 7,
    /// `FAILED_ServiceSelectionInvalid`
    FAILEDServiceSelectionInvalid = 8,
    /// `FAILED_PaymentSelectionInvalid`
    FAILEDPaymentSelectionInvalid = 9,
    /// `FAILED_CertificateExpired`
    FAILEDCertificateExpired = 10,
    /// `FAILED_SignatureError`
    FAILEDSignatureError = 11,
    /// `FAILED_NoCertificateAvailable`
    FAILEDNoCertificateAvailable = 12,
    /// `FAILED_CertChainError`
    FAILEDCertChainError = 13,
    /// `FAILED_ChallengeInvalid`
    FAILEDChallengeInvalid = 14,
    /// `FAILED_ContractCanceled`
    FAILEDContractCanceled = 15,
    /// `FAILED_WrongChargeParameter`
    FAILEDWrongChargeParameter = 16,
    /// `FAILED_PowerDeliveryNotApplied`
    FAILEDPowerDeliveryNotApplied = 17,
    /// `FAILED_TariffSelectionInvalid`
    FAILEDTariffSelectionInvalid = 18,
    /// `FAILED_ChargingProfileInvalid`
    FAILEDChargingProfileInvalid = 19,
    /// `FAILED_MeteringSignatureNotValid`
    FAILEDMeteringSignatureNotValid = 20,
    /// `FAILED_NoChargeServiceSelected`
    FAILEDNoChargeServiceSelected = 21,
    /// `FAILED_WrongEnergyTransferMode`
    FAILEDWrongEnergyTransferMode = 22,
    /// `FAILED_ContactorError`
    FAILEDContactorError = 23,
    /// `FAILED_CertificateNotAllowedAtThisEVSE`
    FAILEDCertificateNotAllowedAtThisEVSE = 24,
    /// `FAILED_CertificateRevoked`
    FAILEDCertificateRevoked = 25,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 26] = [
        Self::OK,
        Self::OKNewSessionEstablished,
        Self::OKOldSessionJoined,
        Self::OKCertificateExpiresSoon,
        Self::FAILED,
        Self::FAILEDSequenceError,
        Self::FAILEDServiceIDInvalid,
        Self::FAILEDUnknownSession,
        Self::FAILEDServiceSelectionInvalid,
        Self::FAILEDPaymentSelectionInvalid,
        Self::FAILEDCertificateExpired,
        Self::FAILEDSignatureError,
        Self::FAILEDNoCertificateAvailable,
        Self::FAILEDCertChainError,
        Self::FAILEDChallengeInvalid,
        Self::FAILEDContractCanceled,
        Self::FAILEDWrongChargeParameter,
        Self::FAILEDPowerDeliveryNotApplied,
        Self::FAILEDTariffSelectionInvalid,
        Self::FAILEDChargingProfileInvalid,
        Self::FAILEDMeteringSignatureNotValid,
        Self::FAILEDNoChargeServiceSelected,
        Self::FAILEDWrongEnergyTransferMode,
        Self::FAILEDContactorError,
        Self::FAILEDCertificateNotAllowedAtThisEVSE,
        Self::FAILEDCertificateRevoked,
    ];

    /// 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::OK,
            1 => Self::OKNewSessionEstablished,
            2 => Self::OKOldSessionJoined,
            3 => Self::OKCertificateExpiresSoon,
            4 => Self::FAILED,
            5 => Self::FAILEDSequenceError,
            6 => Self::FAILEDServiceIDInvalid,
            7 => Self::FAILEDUnknownSession,
            8 => Self::FAILEDServiceSelectionInvalid,
            9 => Self::FAILEDPaymentSelectionInvalid,
            10 => Self::FAILEDCertificateExpired,
            11 => Self::FAILEDSignatureError,
            12 => Self::FAILEDNoCertificateAvailable,
            13 => Self::FAILEDCertChainError,
            14 => Self::FAILEDChallengeInvalid,
            15 => Self::FAILEDContractCanceled,
            16 => Self::FAILEDWrongChargeParameter,
            17 => Self::FAILEDPowerDeliveryNotApplied,
            18 => Self::FAILEDTariffSelectionInvalid,
            19 => Self::FAILEDChargingProfileInvalid,
            20 => Self::FAILEDMeteringSignatureNotValid,
            21 => Self::FAILEDNoChargeServiceSelected,
            22 => Self::FAILEDWrongEnergyTransferMode,
            23 => Self::FAILEDContactorError,
            24 => Self::FAILEDCertificateNotAllowedAtThisEVSE,
            25 => Self::FAILEDCertificateRevoked,
            _ => 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::OK => "OK",
            Self::OKNewSessionEstablished => "OK_NewSessionEstablished",
            Self::OKOldSessionJoined => "OK_OldSessionJoined",
            Self::OKCertificateExpiresSoon => "OK_CertificateExpiresSoon",
            Self::FAILED => "FAILED",
            Self::FAILEDSequenceError => "FAILED_SequenceError",
            Self::FAILEDServiceIDInvalid => "FAILED_ServiceIDInvalid",
            Self::FAILEDUnknownSession => "FAILED_UnknownSession",
            Self::FAILEDServiceSelectionInvalid => "FAILED_ServiceSelectionInvalid",
            Self::FAILEDPaymentSelectionInvalid => "FAILED_PaymentSelectionInvalid",
            Self::FAILEDCertificateExpired => "FAILED_CertificateExpired",
            Self::FAILEDSignatureError => "FAILED_SignatureError",
            Self::FAILEDNoCertificateAvailable => "FAILED_NoCertificateAvailable",
            Self::FAILEDCertChainError => "FAILED_CertChainError",
            Self::FAILEDChallengeInvalid => "FAILED_ChallengeInvalid",
            Self::FAILEDContractCanceled => "FAILED_ContractCanceled",
            Self::FAILEDWrongChargeParameter => "FAILED_WrongChargeParameter",
            Self::FAILEDPowerDeliveryNotApplied => "FAILED_PowerDeliveryNotApplied",
            Self::FAILEDTariffSelectionInvalid => "FAILED_TariffSelectionInvalid",
            Self::FAILEDChargingProfileInvalid => "FAILED_ChargingProfileInvalid",
            Self::FAILEDMeteringSignatureNotValid => "FAILED_MeteringSignatureNotValid",
            Self::FAILEDNoChargeServiceSelected => "FAILED_NoChargeServiceSelected",
            Self::FAILEDWrongEnergyTransferMode => "FAILED_WrongEnergyTransferMode",
            Self::FAILEDContactorError => "FAILED_ContactorError",
            Self::FAILEDCertificateNotAllowedAtThisEVSE => "FAILED_CertificateNotAllowedAtThisEVSE",
            Self::FAILEDCertificateRevoked => "FAILED_CertificateRevoked",
        }
    }
}

impl ResponseCode {
    /// True for an `OK_*` code: the request succeeded.
    #[must_use]
    pub const fn is_ok(self) -> bool {
        matches!(
            self,
            Self::OK
                | Self::OKNewSessionEstablished
                | Self::OKOldSessionJoined
                | Self::OKCertificateExpiresSoon
        )
    }

    /// True for a `WARNING_*` code: the request succeeded, with a
    /// caveat the application should surface. The session continues.
    #[must_use]
    pub const fn is_warning(self) -> bool {
        false
    }

    /// True for a `FAILED_*` code, which **ends the session**.
    ///
    /// ISO 15118 leaves no discretion here: after a failure response
    /// the only request left is `SessionStopReq`. The session cores
    /// enforce that; see `session::Flow::failed`.
    #[must_use]
    pub const fn is_failure(self) -> bool {
        matches!(
            self,
            Self::FAILED
                | Self::FAILEDSequenceError
                | Self::FAILEDServiceIDInvalid
                | Self::FAILEDUnknownSession
                | Self::FAILEDServiceSelectionInvalid
                | Self::FAILEDPaymentSelectionInvalid
                | Self::FAILEDCertificateExpired
                | Self::FAILEDSignatureError
                | Self::FAILEDNoCertificateAvailable
                | Self::FAILEDCertChainError
                | Self::FAILEDChallengeInvalid
                | Self::FAILEDContractCanceled
                | Self::FAILEDWrongChargeParameter
                | Self::FAILEDPowerDeliveryNotApplied
                | Self::FAILEDTariffSelectionInvalid
                | Self::FAILEDChargingProfileInvalid
                | Self::FAILEDMeteringSignatureNotValid
                | Self::FAILEDNoChargeServiceSelected
                | Self::FAILEDWrongEnergyTransferMode
                | Self::FAILEDContactorError
                | Self::FAILEDCertificateNotAllowedAtThisEVSE
                | Self::FAILEDCertificateRevoked
        )
    }
}

/// `serviceCategoryType`.
///
/// 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 ServiceCategory {
    /// `EVCharging`
    EVCharging = 0,
    /// `Internet`
    Internet = 1,
    /// `ContractCertificate`
    ContractCertificate = 2,
    /// `OtherCustom`
    OtherCustom = 3,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 4] =
        [Self::EVCharging, Self::Internet, Self::ContractCertificate, Self::OtherCustom];

    /// 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::EVCharging,
            1 => Self::Internet,
            2 => Self::ContractCertificate,
            3 => Self::OtherCustom,
            _ => 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::EVCharging => "EVCharging",
            Self::Internet => "Internet",
            Self::ContractCertificate => "ContractCertificate",
            Self::OtherCustom => "OtherCustom",
        }
    }
}

/// `unitSymbolType`.
///
/// 7 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 UnitSymbol {
    /// `h`
    H = 0,
    /// `m`
    M = 1,
    /// `s`
    S = 2,
    /// `A`
    A = 3,
    /// `V`
    V = 4,
    /// `W`
    W = 5,
    /// `Wh`
    Wh = 6,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 7] = [Self::H, Self::M, Self::S, Self::A, Self::V, Self::W, Self::Wh];

    /// 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::H,
            1 => Self::M,
            2 => Self::S,
            3 => Self::A,
            4 => Self::V,
            5 => Self::W,
            6 => Self::Wh,
            _ => 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::H => "h",
            Self::M => "m",
            Self::S => "s",
            Self::A => "A",
            Self::V => "V",
            Self::W => "W",
            Self::Wh => "Wh",
        }
    }
}

/// `valueType`.
///
/// 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 Value {
    /// `bool`
    Bool = 0,
    /// `byte`
    Byte = 1,
    /// `short`
    Short = 2,
    /// `int`
    Int = 3,
    /// `physicalValue`
    PhysicalValue = 4,
    /// `string`
    String = 5,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 6] =
        [Self::Bool, Self::Byte, Self::Short, Self::Int, Self::PhysicalValue, Self::String];

    /// 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::Bool,
            1 => Self::Byte,
            2 => Self::Short,
            3 => Self::Int,
            4 => Self::PhysicalValue,
            5 => Self::String,
            _ => 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::Bool => "bool",
            Self::Byte => "byte",
            Self::Short => "short",
            Self::Int => "int",
            Self::PhysicalValue => "physicalValue",
            Self::String => "string",
        }
    }
}

/// `V2GMessage`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct V2GMessage {
    /// `Header` element, 1..1.
    pub header: MessageHeader,
    /// `Body` element, 1..1.
    pub body: Body,
}

impl V2GMessage {
    /// 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 V2GMessage {
    /// 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);
        }
        // Body (1..1)
        {
            let item = &self.body;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl V2GMessage {
    /// 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, .. } => {
                    let value = MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = Body::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            body: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

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

/// 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 — 243 here, against the 80
/// 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 = 244;

/// 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 ACEVChargeParameter {
    /// Document event code of `AC_EVChargeParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 0;
}

impl crate::exi::ExiDocument for ACEVChargeParameter {
    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 ACEVSEChargeParameter {
    /// Document event code of `AC_EVSEChargeParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 1;
}

impl crate::exi::ExiDocument for ACEVSEChargeParameter {
    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 ACEVSEStatus {
    /// Document event code of `AC_EVSEStatus` in this schema set.
    pub const DOCUMENT_CODE: u64 = 2;
}

impl crate::exi::ExiDocument for ACEVSEStatus {
    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 AuthorizationReq {
    /// Document event code of `AuthorizationReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 3;
}

impl crate::exi::ExiDocument for AuthorizationReq {
    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 AuthorizationRes {
    /// Document event code of `AuthorizationRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 4;
}

impl crate::exi::ExiDocument for AuthorizationRes {
    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 BodyBase {
    /// Document event code of `BodyElement` in this schema set.
    pub const DOCUMENT_CODE: u64 = 5;
}

impl crate::exi::ExiDocument for BodyBase {
    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 CableCheckReq {
    /// Document event code of `CableCheckReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 6;
}

impl crate::exi::ExiDocument for CableCheckReq {
    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 CableCheckRes {
    /// Document event code of `CableCheckRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 7;
}

impl crate::exi::ExiDocument for CableCheckRes {
    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 CanonicalizationMethod {
    /// Document event code of `CanonicalizationMethod` in this schema set.
    pub const DOCUMENT_CODE: u64 = 8;
}

impl crate::exi::ExiDocument for CanonicalizationMethod {
    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 CertificateInstallationReq {
    /// Document event code of `CertificateInstallationReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 9;
}

impl crate::exi::ExiDocument for CertificateInstallationReq {
    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 CertificateInstallationRes {
    /// Document event code of `CertificateInstallationRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 10;
}

impl crate::exi::ExiDocument for CertificateInstallationRes {
    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 CertificateUpdateReq {
    /// Document event code of `CertificateUpdateReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 11;
}

impl crate::exi::ExiDocument for CertificateUpdateReq {
    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 CertificateUpdateRes {
    /// Document event code of `CertificateUpdateRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 12;
}

impl crate::exi::ExiDocument for CertificateUpdateRes {
    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 ChargeParameterDiscoveryReq {
    /// Document event code of `ChargeParameterDiscoveryReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 13;
}

impl crate::exi::ExiDocument for ChargeParameterDiscoveryReq {
    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 ChargeParameterDiscoveryRes {
    /// Document event code of `ChargeParameterDiscoveryRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 14;
}

impl crate::exi::ExiDocument for ChargeParameterDiscoveryRes {
    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 ChargingStatusReq {
    /// Document event code of `ChargingStatusReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 15;
}

impl crate::exi::ExiDocument for ChargingStatusReq {
    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 ChargingStatusRes {
    /// Document event code of `ChargingStatusRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 16;
}

impl crate::exi::ExiDocument for ChargingStatusRes {
    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 CurrentDemandReq {
    /// Document event code of `CurrentDemandReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 17;
}

impl crate::exi::ExiDocument for CurrentDemandReq {
    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 CurrentDemandRes {
    /// Document event code of `CurrentDemandRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 18;
}

impl crate::exi::ExiDocument for CurrentDemandRes {
    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 DCEVChargeParameter {
    /// Document event code of `DC_EVChargeParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 19;
}

impl crate::exi::ExiDocument for DCEVChargeParameter {
    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 DCEVPowerDeliveryParameter {
    /// Document event code of `DC_EVPowerDeliveryParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 20;
}

impl crate::exi::ExiDocument for DCEVPowerDeliveryParameter {
    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 DCEVSEChargeParameter {
    /// Document event code of `DC_EVSEChargeParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 21;
}

impl crate::exi::ExiDocument for DCEVSEChargeParameter {
    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 DCEVSEStatus {
    /// Document event code of `DC_EVSEStatus` in this schema set.
    pub const DOCUMENT_CODE: u64 = 22;
}

impl crate::exi::ExiDocument for DCEVSEStatus {
    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 DCEVStatus {
    /// Document event code of `DC_EVStatus` in this schema set.
    pub const DOCUMENT_CODE: u64 = 23;
}

impl crate::exi::ExiDocument for DCEVStatus {
    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 DigestMethod {
    /// Document event code of `DigestMethod` in this schema set.
    pub const DOCUMENT_CODE: u64 = 25;
}

impl crate::exi::ExiDocument for DigestMethod {
    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 EVChargeParameter {
    /// Document event code of `EVChargeParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 27;
}

impl crate::exi::ExiDocument for EVChargeParameter {
    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 EVPowerDeliveryParameter {
    /// Document event code of `EVPowerDeliveryParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 28;
}

impl crate::exi::ExiDocument for EVPowerDeliveryParameter {
    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 EVSEChargeParameter {
    /// Document event code of `EVSEChargeParameter` in this schema set.
    pub const DOCUMENT_CODE: u64 = 29;
}

impl crate::exi::ExiDocument for EVSEChargeParameter {
    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 EVSEStatus {
    /// Document event code of `EVSEStatus` in this schema set.
    pub const DOCUMENT_CODE: u64 = 30;
}

impl crate::exi::ExiDocument for EVSEStatus {
    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 EVStatus {
    /// Document event code of `EVStatus` in this schema set.
    pub const DOCUMENT_CODE: u64 = 31;
}

impl crate::exi::ExiDocument for EVStatus {
    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 Entry {
    /// Document event code of `Entry` in this schema set.
    pub const DOCUMENT_CODE: u64 = 32;
}

impl crate::exi::ExiDocument for Entry {
    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 Manifest {
    /// Document event code of `Manifest` in this schema set.
    pub const DOCUMENT_CODE: u64 = 36;
}

impl crate::exi::ExiDocument for Manifest {
    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 MeteringReceiptReq {
    /// Document event code of `MeteringReceiptReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 37;
}

impl crate::exi::ExiDocument for MeteringReceiptReq {
    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 MeteringReceiptRes {
    /// Document event code of `MeteringReceiptRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 38;
}

impl crate::exi::ExiDocument for MeteringReceiptRes {
    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 PMaxScheduleEntry {
    /// Document event code of `PMaxScheduleEntry` in this schema set.
    pub const DOCUMENT_CODE: u64 = 42;
}

impl crate::exi::ExiDocument for PMaxScheduleEntry {
    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 PaymentDetailsReq {
    /// Document event code of `PaymentDetailsReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 43;
}

impl crate::exi::ExiDocument for PaymentDetailsReq {
    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 PaymentDetailsRes {
    /// Document event code of `PaymentDetailsRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 44;
}

impl crate::exi::ExiDocument for PaymentDetailsRes {
    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 PaymentServiceSelectionReq {
    /// Document event code of `PaymentServiceSelectionReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 45;
}

impl crate::exi::ExiDocument for PaymentServiceSelectionReq {
    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 PaymentServiceSelectionRes {
    /// Document event code of `PaymentServiceSelectionRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 46;
}

impl crate::exi::ExiDocument for PaymentServiceSelectionRes {
    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 PowerDeliveryReq {
    /// Document event code of `PowerDeliveryReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 47;
}

impl crate::exi::ExiDocument for PowerDeliveryReq {
    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 PowerDeliveryRes {
    /// Document event code of `PowerDeliveryRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 48;
}

impl crate::exi::ExiDocument for PowerDeliveryRes {
    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 PreChargeReq {
    /// Document event code of `PreChargeReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 49;
}

impl crate::exi::ExiDocument for PreChargeReq {
    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 PreChargeRes {
    /// Document event code of `PreChargeRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 50;
}

impl crate::exi::ExiDocument for PreChargeRes {
    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 RSAKeyValue {
    /// Document event code of `RSAKeyValue` in this schema set.
    pub const DOCUMENT_CODE: u64 = 51;
}

impl crate::exi::ExiDocument for RSAKeyValue {
    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 Reference {
    /// Document event code of `Reference` in this schema set.
    pub const DOCUMENT_CODE: u64 = 52;
}

impl crate::exi::ExiDocument for Reference {
    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 RelativeTimeInterval {
    /// Document event code of `RelativeTimeInterval` in this schema set.
    pub const DOCUMENT_CODE: u64 = 53;
}

impl crate::exi::ExiDocument for RelativeTimeInterval {
    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 RetrievalMethod {
    /// Document event code of `RetrievalMethod` in this schema set.
    pub const DOCUMENT_CODE: u64 = 54;
}

impl crate::exi::ExiDocument for RetrievalMethod {
    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 SAScheduleList {
    /// Document event code of `SAScheduleList` in this schema set.
    pub const DOCUMENT_CODE: u64 = 55;
}

impl crate::exi::ExiDocument for SAScheduleList {
    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 SASchedules {
    /// Document event code of `SASchedules` in this schema set.
    pub const DOCUMENT_CODE: u64 = 56;
}

impl crate::exi::ExiDocument for SASchedules {
    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 SalesTariffEntry {
    /// Document event code of `SalesTariffEntry` in this schema set.
    pub const DOCUMENT_CODE: u64 = 58;
}

impl crate::exi::ExiDocument for SalesTariffEntry {
    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 ServiceDetailReq {
    /// Document event code of `ServiceDetailReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 59;
}

impl crate::exi::ExiDocument for ServiceDetailReq {
    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 ServiceDetailRes {
    /// Document event code of `ServiceDetailRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 60;
}

impl crate::exi::ExiDocument for ServiceDetailRes {
    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 ServiceDiscoveryReq {
    /// Document event code of `ServiceDiscoveryReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 61;
}

impl crate::exi::ExiDocument for ServiceDiscoveryReq {
    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 ServiceDiscoveryRes {
    /// Document event code of `ServiceDiscoveryRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 62;
}

impl crate::exi::ExiDocument for ServiceDiscoveryRes {
    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 SessionSetupReq {
    /// Document event code of `SessionSetupReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 63;
}

impl crate::exi::ExiDocument for SessionSetupReq {
    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 SessionSetupRes {
    /// Document event code of `SessionSetupRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 64;
}

impl crate::exi::ExiDocument for SessionSetupRes {
    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 SessionStopReq {
    /// Document event code of `SessionStopReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 65;
}

impl crate::exi::ExiDocument for SessionStopReq {
    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 SessionStopRes {
    /// Document event code of `SessionStopRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 66;
}

impl crate::exi::ExiDocument for SessionStopRes {
    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 Signature {
    /// Document event code of `Signature` in this schema set.
    pub const DOCUMENT_CODE: u64 = 67;
}

impl crate::exi::ExiDocument for Signature {
    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 SignatureMethod {
    /// Document event code of `SignatureMethod` in this schema set.
    pub const DOCUMENT_CODE: u64 = 68;
}

impl crate::exi::ExiDocument for SignatureMethod {
    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 SignatureValue {
    /// Document event code of `SignatureValue` in this schema set.
    pub const DOCUMENT_CODE: u64 = 71;
}

impl crate::exi::ExiDocument for SignatureValue {
    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 SignedInfo {
    /// Document event code of `SignedInfo` in this schema set.
    pub const DOCUMENT_CODE: u64 = 72;
}

impl crate::exi::ExiDocument for SignedInfo {
    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 Interval {
    /// Document event code of `TimeInterval` in this schema set.
    pub const DOCUMENT_CODE: u64 = 73;
}

impl crate::exi::ExiDocument for Interval {
    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 Transform {
    /// Document event code of `Transform` in this schema set.
    pub const DOCUMENT_CODE: u64 = 74;
}

impl crate::exi::ExiDocument for Transform {
    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 Transforms {
    /// Document event code of `Transforms` in this schema set.
    pub const DOCUMENT_CODE: u64 = 75;
}

impl crate::exi::ExiDocument for Transforms {
    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 V2GMessage {
    /// Document event code of `V2G_Message` in this schema set.
    pub const DOCUMENT_CODE: u64 = 76;
}

impl crate::exi::ExiDocument for V2GMessage {
    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 WeldingDetectionReq {
    /// Document event code of `WeldingDetectionReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 77;
}

impl crate::exi::ExiDocument for WeldingDetectionReq {
    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 WeldingDetectionRes {
    /// Document event code of `WeldingDetectionRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 78;
}

impl crate::exi::ExiDocument for WeldingDetectionRes {
    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 {
    /// `AC_EVChargeParameter`
    ACEVChargeParameter(ACEVChargeParameter),
    /// `AC_EVSEChargeParameter`
    ACEVSEChargeParameter(ACEVSEChargeParameter),
    /// `AC_EVSEStatus`
    ACEVSEStatus(ACEVSEStatus),
    /// `AuthorizationReq`
    AuthorizationReq(AuthorizationReq),
    /// `AuthorizationRes`
    AuthorizationRes(AuthorizationRes),
    /// `BodyElement`
    BodyElement(BodyBase),
    /// `CableCheckReq`
    CableCheckReq(CableCheckReq),
    /// `CableCheckRes`
    CableCheckRes(CableCheckRes),
    /// `CanonicalizationMethod`
    CanonicalizationMethod(CanonicalizationMethod),
    /// `CertificateInstallationReq`
    CertificateInstallationReq(CertificateInstallationReq),
    /// `CertificateInstallationRes`
    CertificateInstallationRes(CertificateInstallationRes),
    /// `CertificateUpdateReq`
    CertificateUpdateReq(CertificateUpdateReq),
    /// `CertificateUpdateRes`
    CertificateUpdateRes(CertificateUpdateRes),
    /// `ChargeParameterDiscoveryReq`
    ChargeParameterDiscoveryReq(ChargeParameterDiscoveryReq),
    /// `ChargeParameterDiscoveryRes`
    ChargeParameterDiscoveryRes(ChargeParameterDiscoveryRes),
    /// `ChargingStatusReq`
    ChargingStatusReq(ChargingStatusReq),
    /// `ChargingStatusRes`
    ChargingStatusRes(ChargingStatusRes),
    /// `CurrentDemandReq`
    CurrentDemandReq(CurrentDemandReq),
    /// `CurrentDemandRes`
    CurrentDemandRes(CurrentDemandRes),
    /// `DC_EVChargeParameter`
    DCEVChargeParameter(DCEVChargeParameter),
    /// `DC_EVPowerDeliveryParameter`
    DCEVPowerDeliveryParameter(DCEVPowerDeliveryParameter),
    /// `DC_EVSEChargeParameter`
    DCEVSEChargeParameter(DCEVSEChargeParameter),
    /// `DC_EVSEStatus`
    DCEVSEStatus(DCEVSEStatus),
    /// `DC_EVStatus`
    DCEVStatus(DCEVStatus),
    /// `DigestMethod`
    DigestMethod(DigestMethod),
    /// `EVChargeParameter`
    EVChargeParameter(EVChargeParameter),
    /// `EVPowerDeliveryParameter`
    EVPowerDeliveryParameter(EVPowerDeliveryParameter),
    /// `EVSEChargeParameter`
    EVSEChargeParameter(EVSEChargeParameter),
    /// `EVSEStatus`
    EVSEStatus(EVSEStatus),
    /// `EVStatus`
    EVStatus(EVStatus),
    /// `Entry`
    Entry(Entry),
    /// `Manifest`
    Manifest(Manifest),
    /// `MeteringReceiptReq`
    MeteringReceiptReq(MeteringReceiptReq),
    /// `MeteringReceiptRes`
    MeteringReceiptRes(MeteringReceiptRes),
    /// `PMaxScheduleEntry`
    PMaxScheduleEntry(PMaxScheduleEntry),
    /// `PaymentDetailsReq`
    PaymentDetailsReq(PaymentDetailsReq),
    /// `PaymentDetailsRes`
    PaymentDetailsRes(PaymentDetailsRes),
    /// `PaymentServiceSelectionReq`
    PaymentServiceSelectionReq(PaymentServiceSelectionReq),
    /// `PaymentServiceSelectionRes`
    PaymentServiceSelectionRes(PaymentServiceSelectionRes),
    /// `PowerDeliveryReq`
    PowerDeliveryReq(PowerDeliveryReq),
    /// `PowerDeliveryRes`
    PowerDeliveryRes(PowerDeliveryRes),
    /// `PreChargeReq`
    PreChargeReq(PreChargeReq),
    /// `PreChargeRes`
    PreChargeRes(PreChargeRes),
    /// `RSAKeyValue`
    RSAKeyValue(RSAKeyValue),
    /// `Reference`
    Reference(Reference),
    /// `RelativeTimeInterval`
    RelativeTimeInterval(RelativeTimeInterval),
    /// `RetrievalMethod`
    RetrievalMethod(RetrievalMethod),
    /// `SAScheduleList`
    SAScheduleList(SAScheduleList),
    /// `SASchedules`
    SASchedules(SASchedules),
    /// `SalesTariffEntry`
    SalesTariffEntry(SalesTariffEntry),
    /// `ServiceDetailReq`
    ServiceDetailReq(ServiceDetailReq),
    /// `ServiceDetailRes`
    ServiceDetailRes(ServiceDetailRes),
    /// `ServiceDiscoveryReq`
    ServiceDiscoveryReq(ServiceDiscoveryReq),
    /// `ServiceDiscoveryRes`
    ServiceDiscoveryRes(ServiceDiscoveryRes),
    /// `SessionSetupReq`
    SessionSetupReq(SessionSetupReq),
    /// `SessionSetupRes`
    SessionSetupRes(SessionSetupRes),
    /// `SessionStopReq`
    SessionStopReq(SessionStopReq),
    /// `SessionStopRes`
    SessionStopRes(SessionStopRes),
    /// `Signature`
    Signature(Signature),
    /// `SignatureMethod`
    SignatureMethod(SignatureMethod),
    /// `SignatureValue`
    SignatureValue(SignatureValue),
    /// `SignedInfo`
    SignedInfo(SignedInfo),
    /// `TimeInterval`
    TimeInterval(Interval),
    /// `Transform`
    Transform(Transform),
    /// `Transforms`
    Transforms(Transforms),
    /// `V2G_Message`
    V2GMessage(V2GMessage),
    /// `WeldingDetectionReq`
    WeldingDetectionReq(WeldingDetectionReq),
    /// `WeldingDetectionRes`
    WeldingDetectionRes(WeldingDetectionRes),
}

impl Document {
    /// The element name of this document.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::ACEVChargeParameter(_) => "AC_EVChargeParameter",
            Self::ACEVSEChargeParameter(_) => "AC_EVSEChargeParameter",
            Self::ACEVSEStatus(_) => "AC_EVSEStatus",
            Self::AuthorizationReq(_) => "AuthorizationReq",
            Self::AuthorizationRes(_) => "AuthorizationRes",
            Self::BodyElement(_) => "BodyElement",
            Self::CableCheckReq(_) => "CableCheckReq",
            Self::CableCheckRes(_) => "CableCheckRes",
            Self::CanonicalizationMethod(_) => "CanonicalizationMethod",
            Self::CertificateInstallationReq(_) => "CertificateInstallationReq",
            Self::CertificateInstallationRes(_) => "CertificateInstallationRes",
            Self::CertificateUpdateReq(_) => "CertificateUpdateReq",
            Self::CertificateUpdateRes(_) => "CertificateUpdateRes",
            Self::ChargeParameterDiscoveryReq(_) => "ChargeParameterDiscoveryReq",
            Self::ChargeParameterDiscoveryRes(_) => "ChargeParameterDiscoveryRes",
            Self::ChargingStatusReq(_) => "ChargingStatusReq",
            Self::ChargingStatusRes(_) => "ChargingStatusRes",
            Self::CurrentDemandReq(_) => "CurrentDemandReq",
            Self::CurrentDemandRes(_) => "CurrentDemandRes",
            Self::DCEVChargeParameter(_) => "DC_EVChargeParameter",
            Self::DCEVPowerDeliveryParameter(_) => "DC_EVPowerDeliveryParameter",
            Self::DCEVSEChargeParameter(_) => "DC_EVSEChargeParameter",
            Self::DCEVSEStatus(_) => "DC_EVSEStatus",
            Self::DCEVStatus(_) => "DC_EVStatus",
            Self::DigestMethod(_) => "DigestMethod",
            Self::EVChargeParameter(_) => "EVChargeParameter",
            Self::EVPowerDeliveryParameter(_) => "EVPowerDeliveryParameter",
            Self::EVSEChargeParameter(_) => "EVSEChargeParameter",
            Self::EVSEStatus(_) => "EVSEStatus",
            Self::EVStatus(_) => "EVStatus",
            Self::Entry(_) => "Entry",
            Self::Manifest(_) => "Manifest",
            Self::MeteringReceiptReq(_) => "MeteringReceiptReq",
            Self::MeteringReceiptRes(_) => "MeteringReceiptRes",
            Self::PMaxScheduleEntry(_) => "PMaxScheduleEntry",
            Self::PaymentDetailsReq(_) => "PaymentDetailsReq",
            Self::PaymentDetailsRes(_) => "PaymentDetailsRes",
            Self::PaymentServiceSelectionReq(_) => "PaymentServiceSelectionReq",
            Self::PaymentServiceSelectionRes(_) => "PaymentServiceSelectionRes",
            Self::PowerDeliveryReq(_) => "PowerDeliveryReq",
            Self::PowerDeliveryRes(_) => "PowerDeliveryRes",
            Self::PreChargeReq(_) => "PreChargeReq",
            Self::PreChargeRes(_) => "PreChargeRes",
            Self::RSAKeyValue(_) => "RSAKeyValue",
            Self::Reference(_) => "Reference",
            Self::RelativeTimeInterval(_) => "RelativeTimeInterval",
            Self::RetrievalMethod(_) => "RetrievalMethod",
            Self::SAScheduleList(_) => "SAScheduleList",
            Self::SASchedules(_) => "SASchedules",
            Self::SalesTariffEntry(_) => "SalesTariffEntry",
            Self::ServiceDetailReq(_) => "ServiceDetailReq",
            Self::ServiceDetailRes(_) => "ServiceDetailRes",
            Self::ServiceDiscoveryReq(_) => "ServiceDiscoveryReq",
            Self::ServiceDiscoveryRes(_) => "ServiceDiscoveryRes",
            Self::SessionSetupReq(_) => "SessionSetupReq",
            Self::SessionSetupRes(_) => "SessionSetupRes",
            Self::SessionStopReq(_) => "SessionStopReq",
            Self::SessionStopRes(_) => "SessionStopRes",
            Self::Signature(_) => "Signature",
            Self::SignatureMethod(_) => "SignatureMethod",
            Self::SignatureValue(_) => "SignatureValue",
            Self::SignedInfo(_) => "SignedInfo",
            Self::TimeInterval(_) => "TimeInterval",
            Self::Transform(_) => "Transform",
            Self::Transforms(_) => "Transforms",
            Self::V2GMessage(_) => "V2G_Message",
            Self::WeldingDetectionReq(_) => "WeldingDetectionReq",
            Self::WeldingDetectionRes(_) => "WeldingDetectionRes",
        }
    }

    /// The document event code of this message.
    #[must_use]
    pub const fn code(&self) -> u64 {
        match self {
            Self::ACEVChargeParameter(_) => 0,
            Self::ACEVSEChargeParameter(_) => 1,
            Self::ACEVSEStatus(_) => 2,
            Self::AuthorizationReq(_) => 3,
            Self::AuthorizationRes(_) => 4,
            Self::BodyElement(_) => 5,
            Self::CableCheckReq(_) => 6,
            Self::CableCheckRes(_) => 7,
            Self::CanonicalizationMethod(_) => 8,
            Self::CertificateInstallationReq(_) => 9,
            Self::CertificateInstallationRes(_) => 10,
            Self::CertificateUpdateReq(_) => 11,
            Self::CertificateUpdateRes(_) => 12,
            Self::ChargeParameterDiscoveryReq(_) => 13,
            Self::ChargeParameterDiscoveryRes(_) => 14,
            Self::ChargingStatusReq(_) => 15,
            Self::ChargingStatusRes(_) => 16,
            Self::CurrentDemandReq(_) => 17,
            Self::CurrentDemandRes(_) => 18,
            Self::DCEVChargeParameter(_) => 19,
            Self::DCEVPowerDeliveryParameter(_) => 20,
            Self::DCEVSEChargeParameter(_) => 21,
            Self::DCEVSEStatus(_) => 22,
            Self::DCEVStatus(_) => 23,
            Self::DigestMethod(_) => 25,
            Self::EVChargeParameter(_) => 27,
            Self::EVPowerDeliveryParameter(_) => 28,
            Self::EVSEChargeParameter(_) => 29,
            Self::EVSEStatus(_) => 30,
            Self::EVStatus(_) => 31,
            Self::Entry(_) => 32,
            Self::Manifest(_) => 36,
            Self::MeteringReceiptReq(_) => 37,
            Self::MeteringReceiptRes(_) => 38,
            Self::PMaxScheduleEntry(_) => 42,
            Self::PaymentDetailsReq(_) => 43,
            Self::PaymentDetailsRes(_) => 44,
            Self::PaymentServiceSelectionReq(_) => 45,
            Self::PaymentServiceSelectionRes(_) => 46,
            Self::PowerDeliveryReq(_) => 47,
            Self::PowerDeliveryRes(_) => 48,
            Self::PreChargeReq(_) => 49,
            Self::PreChargeRes(_) => 50,
            Self::RSAKeyValue(_) => 51,
            Self::Reference(_) => 52,
            Self::RelativeTimeInterval(_) => 53,
            Self::RetrievalMethod(_) => 54,
            Self::SAScheduleList(_) => 55,
            Self::SASchedules(_) => 56,
            Self::SalesTariffEntry(_) => 58,
            Self::ServiceDetailReq(_) => 59,
            Self::ServiceDetailRes(_) => 60,
            Self::ServiceDiscoveryReq(_) => 61,
            Self::ServiceDiscoveryRes(_) => 62,
            Self::SessionSetupReq(_) => 63,
            Self::SessionSetupRes(_) => 64,
            Self::SessionStopReq(_) => 65,
            Self::SessionStopRes(_) => 66,
            Self::Signature(_) => 67,
            Self::SignatureMethod(_) => 68,
            Self::SignatureValue(_) => 71,
            Self::SignedInfo(_) => 72,
            Self::TimeInterval(_) => 73,
            Self::Transform(_) => 74,
            Self::Transforms(_) => 75,
            Self::V2GMessage(_) => 76,
            Self::WeldingDetectionReq(_) => 77,
            Self::WeldingDetectionRes(_) => 78,
        }
    }
}

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::ACEVChargeParameter(m) => m.encode_body(&mut e)?,
            Self::ACEVSEChargeParameter(m) => m.encode_body(&mut e)?,
            Self::ACEVSEStatus(m) => m.encode_body(&mut e)?,
            Self::AuthorizationReq(m) => m.encode_body(&mut e)?,
            Self::AuthorizationRes(m) => m.encode_body(&mut e)?,
            Self::BodyElement(m) => m.encode_body(&mut e)?,
            Self::CableCheckReq(m) => m.encode_body(&mut e)?,
            Self::CableCheckRes(m) => m.encode_body(&mut e)?,
            Self::CanonicalizationMethod(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationReq(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationRes(m) => m.encode_body(&mut e)?,
            Self::CertificateUpdateReq(m) => m.encode_body(&mut e)?,
            Self::CertificateUpdateRes(m) => m.encode_body(&mut e)?,
            Self::ChargeParameterDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::ChargeParameterDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::ChargingStatusReq(m) => m.encode_body(&mut e)?,
            Self::ChargingStatusRes(m) => m.encode_body(&mut e)?,
            Self::CurrentDemandReq(m) => m.encode_body(&mut e)?,
            Self::CurrentDemandRes(m) => m.encode_body(&mut e)?,
            Self::DCEVChargeParameter(m) => m.encode_body(&mut e)?,
            Self::DCEVPowerDeliveryParameter(m) => m.encode_body(&mut e)?,
            Self::DCEVSEChargeParameter(m) => m.encode_body(&mut e)?,
            Self::DCEVSEStatus(m) => m.encode_body(&mut e)?,
            Self::DCEVStatus(m) => m.encode_body(&mut e)?,
            Self::DigestMethod(m) => m.encode_body(&mut e)?,
            Self::EVChargeParameter(m) => m.encode_body(&mut e)?,
            Self::EVPowerDeliveryParameter(m) => m.encode_body(&mut e)?,
            Self::EVSEChargeParameter(m) => m.encode_body(&mut e)?,
            Self::EVSEStatus(m) => m.encode_body(&mut e)?,
            Self::EVStatus(m) => m.encode_body(&mut e)?,
            Self::Entry(m) => m.encode_body(&mut e)?,
            Self::Manifest(m) => m.encode_body(&mut e)?,
            Self::MeteringReceiptReq(m) => m.encode_body(&mut e)?,
            Self::MeteringReceiptRes(m) => m.encode_body(&mut e)?,
            Self::PMaxScheduleEntry(m) => m.encode_body(&mut e)?,
            Self::PaymentDetailsReq(m) => m.encode_body(&mut e)?,
            Self::PaymentDetailsRes(m) => m.encode_body(&mut e)?,
            Self::PaymentServiceSelectionReq(m) => m.encode_body(&mut e)?,
            Self::PaymentServiceSelectionRes(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryReq(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryRes(m) => m.encode_body(&mut e)?,
            Self::PreChargeReq(m) => m.encode_body(&mut e)?,
            Self::PreChargeRes(m) => m.encode_body(&mut e)?,
            Self::RSAKeyValue(m) => m.encode_body(&mut e)?,
            Self::Reference(m) => m.encode_body(&mut e)?,
            Self::RelativeTimeInterval(m) => m.encode_body(&mut e)?,
            Self::RetrievalMethod(m) => m.encode_body(&mut e)?,
            Self::SAScheduleList(m) => m.encode_body(&mut e)?,
            Self::SASchedules(m) => m.encode_body(&mut e)?,
            Self::SalesTariffEntry(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailRes(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::SessionSetupReq(m) => m.encode_body(&mut e)?,
            Self::SessionSetupRes(m) => m.encode_body(&mut e)?,
            Self::SessionStopReq(m) => m.encode_body(&mut e)?,
            Self::SessionStopRes(m) => m.encode_body(&mut e)?,
            Self::Signature(m) => m.encode_body(&mut e)?,
            Self::SignatureMethod(m) => m.encode_body(&mut e)?,
            Self::SignatureValue(m) => m.encode_body(&mut e)?,
            Self::SignedInfo(m) => m.encode_body(&mut e)?,
            Self::TimeInterval(m) => m.encode_body(&mut e)?,
            Self::Transform(m) => m.encode_body(&mut e)?,
            Self::Transforms(m) => m.encode_body(&mut e)?,
            Self::V2GMessage(m) => m.encode_body(&mut e)?,
            Self::WeldingDetectionReq(m) => m.encode_body(&mut e)?,
            Self::WeldingDetectionRes(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)? {
            0 => Self::ACEVChargeParameter(ACEVChargeParameter::decode_body(&mut d)?),
            1 => Self::ACEVSEChargeParameter(ACEVSEChargeParameter::decode_body(&mut d)?),
            2 => Self::ACEVSEStatus(ACEVSEStatus::decode_body(&mut d)?),
            3 => Self::AuthorizationReq(AuthorizationReq::decode_body(&mut d)?),
            4 => Self::AuthorizationRes(AuthorizationRes::decode_body(&mut d)?),
            5 => Self::BodyElement(BodyBase::decode_body(&mut d)?),
            6 => Self::CableCheckReq(CableCheckReq::decode_body(&mut d)?),
            7 => Self::CableCheckRes(CableCheckRes::decode_body(&mut d)?),
            8 => Self::CanonicalizationMethod(CanonicalizationMethod::decode_body(&mut d)?),
            9 => Self::CertificateInstallationReq(CertificateInstallationReq::decode_body(&mut d)?),
            10 => {
                Self::CertificateInstallationRes(CertificateInstallationRes::decode_body(&mut d)?)
            }
            11 => Self::CertificateUpdateReq(CertificateUpdateReq::decode_body(&mut d)?),
            12 => Self::CertificateUpdateRes(CertificateUpdateRes::decode_body(&mut d)?),
            13 => {
                Self::ChargeParameterDiscoveryReq(ChargeParameterDiscoveryReq::decode_body(&mut d)?)
            }
            14 => {
                Self::ChargeParameterDiscoveryRes(ChargeParameterDiscoveryRes::decode_body(&mut d)?)
            }
            15 => Self::ChargingStatusReq(ChargingStatusReq::decode_body(&mut d)?),
            16 => Self::ChargingStatusRes(ChargingStatusRes::decode_body(&mut d)?),
            17 => Self::CurrentDemandReq(CurrentDemandReq::decode_body(&mut d)?),
            18 => Self::CurrentDemandRes(CurrentDemandRes::decode_body(&mut d)?),
            19 => Self::DCEVChargeParameter(DCEVChargeParameter::decode_body(&mut d)?),
            20 => {
                Self::DCEVPowerDeliveryParameter(DCEVPowerDeliveryParameter::decode_body(&mut d)?)
            }
            21 => Self::DCEVSEChargeParameter(DCEVSEChargeParameter::decode_body(&mut d)?),
            22 => Self::DCEVSEStatus(DCEVSEStatus::decode_body(&mut d)?),
            23 => Self::DCEVStatus(DCEVStatus::decode_body(&mut d)?),
            25 => Self::DigestMethod(DigestMethod::decode_body(&mut d)?),
            27 => Self::EVChargeParameter(EVChargeParameter::decode_body(&mut d)?),
            28 => Self::EVPowerDeliveryParameter(EVPowerDeliveryParameter::decode_body(&mut d)?),
            29 => Self::EVSEChargeParameter(EVSEChargeParameter::decode_body(&mut d)?),
            30 => Self::EVSEStatus(EVSEStatus::decode_body(&mut d)?),
            31 => Self::EVStatus(EVStatus::decode_body(&mut d)?),
            32 => Self::Entry(Entry::decode_body(&mut d)?),
            36 => Self::Manifest(Manifest::decode_body(&mut d)?),
            37 => Self::MeteringReceiptReq(MeteringReceiptReq::decode_body(&mut d)?),
            38 => Self::MeteringReceiptRes(MeteringReceiptRes::decode_body(&mut d)?),
            42 => Self::PMaxScheduleEntry(PMaxScheduleEntry::decode_body(&mut d)?),
            43 => Self::PaymentDetailsReq(PaymentDetailsReq::decode_body(&mut d)?),
            44 => Self::PaymentDetailsRes(PaymentDetailsRes::decode_body(&mut d)?),
            45 => {
                Self::PaymentServiceSelectionReq(PaymentServiceSelectionReq::decode_body(&mut d)?)
            }
            46 => {
                Self::PaymentServiceSelectionRes(PaymentServiceSelectionRes::decode_body(&mut d)?)
            }
            47 => Self::PowerDeliveryReq(PowerDeliveryReq::decode_body(&mut d)?),
            48 => Self::PowerDeliveryRes(PowerDeliveryRes::decode_body(&mut d)?),
            49 => Self::PreChargeReq(PreChargeReq::decode_body(&mut d)?),
            50 => Self::PreChargeRes(PreChargeRes::decode_body(&mut d)?),
            51 => Self::RSAKeyValue(RSAKeyValue::decode_body(&mut d)?),
            52 => Self::Reference(Reference::decode_body(&mut d)?),
            53 => Self::RelativeTimeInterval(RelativeTimeInterval::decode_body(&mut d)?),
            54 => Self::RetrievalMethod(RetrievalMethod::decode_body(&mut d)?),
            55 => Self::SAScheduleList(SAScheduleList::decode_body(&mut d)?),
            56 => Self::SASchedules(SASchedules::decode_body(&mut d)?),
            58 => Self::SalesTariffEntry(SalesTariffEntry::decode_body(&mut d)?),
            59 => Self::ServiceDetailReq(ServiceDetailReq::decode_body(&mut d)?),
            60 => Self::ServiceDetailRes(ServiceDetailRes::decode_body(&mut d)?),
            61 => Self::ServiceDiscoveryReq(ServiceDiscoveryReq::decode_body(&mut d)?),
            62 => Self::ServiceDiscoveryRes(ServiceDiscoveryRes::decode_body(&mut d)?),
            63 => Self::SessionSetupReq(SessionSetupReq::decode_body(&mut d)?),
            64 => Self::SessionSetupRes(SessionSetupRes::decode_body(&mut d)?),
            65 => Self::SessionStopReq(SessionStopReq::decode_body(&mut d)?),
            66 => Self::SessionStopRes(SessionStopRes::decode_body(&mut d)?),
            67 => Self::Signature(Signature::decode_body(&mut d)?),
            68 => Self::SignatureMethod(SignatureMethod::decode_body(&mut d)?),
            71 => Self::SignatureValue(SignatureValue::decode_body(&mut d)?),
            72 => Self::SignedInfo(SignedInfo::decode_body(&mut d)?),
            73 => Self::TimeInterval(Interval::decode_body(&mut d)?),
            74 => Self::Transform(Transform::decode_body(&mut d)?),
            75 => Self::Transforms(Transforms::decode_body(&mut d)?),
            76 => Self::V2GMessage(V2GMessage::decode_body(&mut d)?),
            77 => Self::WeldingDetectionReq(WeldingDetectionReq::decode_body(&mut d)?),
            78 => Self::WeldingDetectionRes(WeldingDetectionRes::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.finish()?;
        Ok(value)
    }
}

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<ResponseCode> {
        match self {
            Self::AuthorizationRes(m) => Some(m.response_code),
            Self::CableCheckRes(m) => Some(m.response_code),
            Self::CertificateInstallationRes(m) => Some(m.response_code),
            Self::CertificateUpdateRes(m) => Some(m.response_code),
            Self::ChargeParameterDiscoveryRes(m) => Some(m.response_code),
            Self::ChargingStatusRes(m) => Some(m.response_code),
            Self::CurrentDemandRes(m) => Some(m.response_code),
            Self::MeteringReceiptRes(m) => Some(m.response_code),
            Self::PaymentDetailsRes(m) => Some(m.response_code),
            Self::PaymentServiceSelectionRes(m) => Some(m.response_code),
            Self::PowerDeliveryRes(m) => Some(m.response_code),
            Self::PreChargeRes(m) => Some(m.response_code),
            Self::ServiceDetailRes(m) => Some(m.response_code),
            Self::ServiceDiscoveryRes(m) => Some(m.response_code),
            Self::SessionSetupRes(m) => Some(m.response_code),
            Self::SessionStopRes(m) => Some(m.response_code),
            Self::WeldingDetectionRes(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::ACEVChargeParameter(_) => 0,
            Self::ACEVSEChargeParameter(_) => 1,
            Self::ACEVSEStatus(_) => 3,
            Self::AuthorizationReq(_) => 4,
            Self::AuthorizationRes(_) => 5,
            Self::BodyElement(_) => 7,
            Self::CableCheckReq(_) => 11,
            Self::CableCheckRes(_) => 12,
            Self::CanonicalizationMethod(_) => 13,
            Self::CertificateInstallationReq(_) => 15,
            Self::CertificateInstallationRes(_) => 16,
            Self::CertificateUpdateReq(_) => 17,
            Self::CertificateUpdateRes(_) => 18,
            Self::ChargeParameterDiscoveryReq(_) => 19,
            Self::ChargeParameterDiscoveryRes(_) => 20,
            Self::ChargingStatusReq(_) => 30,
            Self::ChargingStatusRes(_) => 31,
            Self::CurrentDemandReq(_) => 36,
            Self::CurrentDemandRes(_) => 37,
            Self::DCEVChargeParameter(_) => 38,
            Self::DCEVPowerDeliveryParameter(_) => 39,
            Self::DCEVSEChargeParameter(_) => 40,
            Self::DCEVSEStatus(_) => 42,
            Self::DCEVStatus(_) => 44,
            Self::DigestMethod(_) => 48,
            Self::EVChargeParameter(_) => 53,
            Self::EVPowerDeliveryParameter(_) => 66,
            Self::EVSEChargeParameter(_) => 69,
            Self::EVSEStatus(_) => 92,
            Self::EVStatus(_) => 96,
            Self::Entry(_) => 100,
            Self::Manifest(_) => 115,
            Self::MeteringReceiptReq(_) => 121,
            Self::MeteringReceiptRes(_) => 122,
            Self::PMaxScheduleEntry(_) => 137,
            Self::PaymentDetailsReq(_) => 141,
            Self::PaymentDetailsRes(_) => 142,
            Self::PaymentServiceSelectionReq(_) => 145,
            Self::PaymentServiceSelectionRes(_) => 146,
            Self::PowerDeliveryReq(_) => 148,
            Self::PowerDeliveryRes(_) => 149,
            Self::PreChargeReq(_) => 150,
            Self::PreChargeRes(_) => 151,
            Self::RSAKeyValue(_) => 155,
            Self::Reference(_) => 157,
            Self::RelativeTimeInterval(_) => 158,
            Self::RetrievalMethod(_) => 163,
            Self::SAScheduleList(_) => 167,
            Self::SASchedules(_) => 171,
            Self::SalesTariffEntry(_) => 176,
            Self::ServiceDetailReq(_) => 185,
            Self::ServiceDetailRes(_) => 186,
            Self::ServiceDiscoveryReq(_) => 187,
            Self::ServiceDiscoveryRes(_) => 188,
            Self::SessionSetupReq(_) => 198,
            Self::SessionSetupRes(_) => 199,
            Self::SessionStopReq(_) => 200,
            Self::SessionStopRes(_) => 201,
            Self::Signature(_) => 203,
            Self::SignatureMethod(_) => 204,
            Self::SignatureValue(_) => 207,
            Self::SignedInfo(_) => 208,
            Self::TimeInterval(_) => 212,
            Self::Transform(_) => 213,
            Self::Transforms(_) => 214,
            Self::V2GMessage(_) => 216,
            Self::WeldingDetectionReq(_) => 218,
            Self::WeldingDetectionRes(_) => 219,
        }
    }

    /// 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::ACEVChargeParameter(m) => m.encode_body(&mut e)?,
            Self::ACEVSEChargeParameter(m) => m.encode_body(&mut e)?,
            Self::ACEVSEStatus(m) => m.encode_body(&mut e)?,
            Self::AuthorizationReq(m) => m.encode_body(&mut e)?,
            Self::AuthorizationRes(m) => m.encode_body(&mut e)?,
            Self::BodyElement(m) => m.encode_body(&mut e)?,
            Self::CableCheckReq(m) => m.encode_body(&mut e)?,
            Self::CableCheckRes(m) => m.encode_body(&mut e)?,
            Self::CanonicalizationMethod(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationReq(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationRes(m) => m.encode_body(&mut e)?,
            Self::CertificateUpdateReq(m) => m.encode_body(&mut e)?,
            Self::CertificateUpdateRes(m) => m.encode_body(&mut e)?,
            Self::ChargeParameterDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::ChargeParameterDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::ChargingStatusReq(m) => m.encode_body(&mut e)?,
            Self::ChargingStatusRes(m) => m.encode_body(&mut e)?,
            Self::CurrentDemandReq(m) => m.encode_body(&mut e)?,
            Self::CurrentDemandRes(m) => m.encode_body(&mut e)?,
            Self::DCEVChargeParameter(m) => m.encode_body(&mut e)?,
            Self::DCEVPowerDeliveryParameter(m) => m.encode_body(&mut e)?,
            Self::DCEVSEChargeParameter(m) => m.encode_body(&mut e)?,
            Self::DCEVSEStatus(m) => m.encode_body(&mut e)?,
            Self::DCEVStatus(m) => m.encode_body(&mut e)?,
            Self::DigestMethod(m) => m.encode_body(&mut e)?,
            Self::EVChargeParameter(m) => m.encode_body(&mut e)?,
            Self::EVPowerDeliveryParameter(m) => m.encode_body(&mut e)?,
            Self::EVSEChargeParameter(m) => m.encode_body(&mut e)?,
            Self::EVSEStatus(m) => m.encode_body(&mut e)?,
            Self::EVStatus(m) => m.encode_body(&mut e)?,
            Self::Entry(m) => m.encode_body(&mut e)?,
            Self::Manifest(m) => m.encode_body(&mut e)?,
            Self::MeteringReceiptReq(m) => m.encode_body(&mut e)?,
            Self::MeteringReceiptRes(m) => m.encode_body(&mut e)?,
            Self::PMaxScheduleEntry(m) => m.encode_body(&mut e)?,
            Self::PaymentDetailsReq(m) => m.encode_body(&mut e)?,
            Self::PaymentDetailsRes(m) => m.encode_body(&mut e)?,
            Self::PaymentServiceSelectionReq(m) => m.encode_body(&mut e)?,
            Self::PaymentServiceSelectionRes(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryReq(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryRes(m) => m.encode_body(&mut e)?,
            Self::PreChargeReq(m) => m.encode_body(&mut e)?,
            Self::PreChargeRes(m) => m.encode_body(&mut e)?,
            Self::RSAKeyValue(m) => m.encode_body(&mut e)?,
            Self::Reference(m) => m.encode_body(&mut e)?,
            Self::RelativeTimeInterval(m) => m.encode_body(&mut e)?,
            Self::RetrievalMethod(m) => m.encode_body(&mut e)?,
            Self::SAScheduleList(m) => m.encode_body(&mut e)?,
            Self::SASchedules(m) => m.encode_body(&mut e)?,
            Self::SalesTariffEntry(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailRes(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::SessionSetupReq(m) => m.encode_body(&mut e)?,
            Self::SessionSetupRes(m) => m.encode_body(&mut e)?,
            Self::SessionStopReq(m) => m.encode_body(&mut e)?,
            Self::SessionStopRes(m) => m.encode_body(&mut e)?,
            Self::Signature(m) => m.encode_body(&mut e)?,
            Self::SignatureMethod(m) => m.encode_body(&mut e)?,
            Self::SignatureValue(m) => m.encode_body(&mut e)?,
            Self::SignedInfo(m) => m.encode_body(&mut e)?,
            Self::TimeInterval(m) => m.encode_body(&mut e)?,
            Self::Transform(m) => m.encode_body(&mut e)?,
            Self::Transforms(m) => m.encode_body(&mut e)?,
            Self::V2GMessage(m) => m.encode_body(&mut e)?,
            Self::WeldingDetectionReq(m) => m.encode_body(&mut e)?,
            Self::WeldingDetectionRes(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)? {
            0 => Self::ACEVChargeParameter(ACEVChargeParameter::decode_body(&mut d)?),
            1 => Self::ACEVSEChargeParameter(ACEVSEChargeParameter::decode_body(&mut d)?),
            3 => Self::ACEVSEStatus(ACEVSEStatus::decode_body(&mut d)?),
            4 => Self::AuthorizationReq(AuthorizationReq::decode_body(&mut d)?),
            5 => Self::AuthorizationRes(AuthorizationRes::decode_body(&mut d)?),
            7 => Self::BodyElement(BodyBase::decode_body(&mut d)?),
            11 => Self::CableCheckReq(CableCheckReq::decode_body(&mut d)?),
            12 => Self::CableCheckRes(CableCheckRes::decode_body(&mut d)?),
            13 => Self::CanonicalizationMethod(CanonicalizationMethod::decode_body(&mut d)?),
            15 => {
                Self::CertificateInstallationReq(CertificateInstallationReq::decode_body(&mut d)?)
            }
            16 => {
                Self::CertificateInstallationRes(CertificateInstallationRes::decode_body(&mut d)?)
            }
            17 => Self::CertificateUpdateReq(CertificateUpdateReq::decode_body(&mut d)?),
            18 => Self::CertificateUpdateRes(CertificateUpdateRes::decode_body(&mut d)?),
            19 => {
                Self::ChargeParameterDiscoveryReq(ChargeParameterDiscoveryReq::decode_body(&mut d)?)
            }
            20 => {
                Self::ChargeParameterDiscoveryRes(ChargeParameterDiscoveryRes::decode_body(&mut d)?)
            }
            30 => Self::ChargingStatusReq(ChargingStatusReq::decode_body(&mut d)?),
            31 => Self::ChargingStatusRes(ChargingStatusRes::decode_body(&mut d)?),
            36 => Self::CurrentDemandReq(CurrentDemandReq::decode_body(&mut d)?),
            37 => Self::CurrentDemandRes(CurrentDemandRes::decode_body(&mut d)?),
            38 => Self::DCEVChargeParameter(DCEVChargeParameter::decode_body(&mut d)?),
            39 => {
                Self::DCEVPowerDeliveryParameter(DCEVPowerDeliveryParameter::decode_body(&mut d)?)
            }
            40 => Self::DCEVSEChargeParameter(DCEVSEChargeParameter::decode_body(&mut d)?),
            42 => Self::DCEVSEStatus(DCEVSEStatus::decode_body(&mut d)?),
            44 => Self::DCEVStatus(DCEVStatus::decode_body(&mut d)?),
            48 => Self::DigestMethod(DigestMethod::decode_body(&mut d)?),
            53 => Self::EVChargeParameter(EVChargeParameter::decode_body(&mut d)?),
            66 => Self::EVPowerDeliveryParameter(EVPowerDeliveryParameter::decode_body(&mut d)?),
            69 => Self::EVSEChargeParameter(EVSEChargeParameter::decode_body(&mut d)?),
            92 => Self::EVSEStatus(EVSEStatus::decode_body(&mut d)?),
            96 => Self::EVStatus(EVStatus::decode_body(&mut d)?),
            100 => Self::Entry(Entry::decode_body(&mut d)?),
            115 => Self::Manifest(Manifest::decode_body(&mut d)?),
            121 => Self::MeteringReceiptReq(MeteringReceiptReq::decode_body(&mut d)?),
            122 => Self::MeteringReceiptRes(MeteringReceiptRes::decode_body(&mut d)?),
            137 => Self::PMaxScheduleEntry(PMaxScheduleEntry::decode_body(&mut d)?),
            141 => Self::PaymentDetailsReq(PaymentDetailsReq::decode_body(&mut d)?),
            142 => Self::PaymentDetailsRes(PaymentDetailsRes::decode_body(&mut d)?),
            145 => {
                Self::PaymentServiceSelectionReq(PaymentServiceSelectionReq::decode_body(&mut d)?)
            }
            146 => {
                Self::PaymentServiceSelectionRes(PaymentServiceSelectionRes::decode_body(&mut d)?)
            }
            148 => Self::PowerDeliveryReq(PowerDeliveryReq::decode_body(&mut d)?),
            149 => Self::PowerDeliveryRes(PowerDeliveryRes::decode_body(&mut d)?),
            150 => Self::PreChargeReq(PreChargeReq::decode_body(&mut d)?),
            151 => Self::PreChargeRes(PreChargeRes::decode_body(&mut d)?),
            155 => Self::RSAKeyValue(RSAKeyValue::decode_body(&mut d)?),
            157 => Self::Reference(Reference::decode_body(&mut d)?),
            158 => Self::RelativeTimeInterval(RelativeTimeInterval::decode_body(&mut d)?),
            163 => Self::RetrievalMethod(RetrievalMethod::decode_body(&mut d)?),
            167 => Self::SAScheduleList(SAScheduleList::decode_body(&mut d)?),
            171 => Self::SASchedules(SASchedules::decode_body(&mut d)?),
            176 => Self::SalesTariffEntry(SalesTariffEntry::decode_body(&mut d)?),
            185 => Self::ServiceDetailReq(ServiceDetailReq::decode_body(&mut d)?),
            186 => Self::ServiceDetailRes(ServiceDetailRes::decode_body(&mut d)?),
            187 => Self::ServiceDiscoveryReq(ServiceDiscoveryReq::decode_body(&mut d)?),
            188 => Self::ServiceDiscoveryRes(ServiceDiscoveryRes::decode_body(&mut d)?),
            198 => Self::SessionSetupReq(SessionSetupReq::decode_body(&mut d)?),
            199 => Self::SessionSetupRes(SessionSetupRes::decode_body(&mut d)?),
            200 => Self::SessionStopReq(SessionStopReq::decode_body(&mut d)?),
            201 => Self::SessionStopRes(SessionStopRes::decode_body(&mut d)?),
            203 => Self::Signature(Signature::decode_body(&mut d)?),
            204 => Self::SignatureMethod(SignatureMethod::decode_body(&mut d)?),
            207 => Self::SignatureValue(SignatureValue::decode_body(&mut d)?),
            208 => Self::SignedInfo(SignedInfo::decode_body(&mut d)?),
            212 => Self::TimeInterval(Interval::decode_body(&mut d)?),
            213 => Self::Transform(Transform::decode_body(&mut d)?),
            214 => Self::Transforms(Transforms::decode_body(&mut d)?),
            216 => Self::V2GMessage(V2GMessage::decode_body(&mut d)?),
            218 => Self::WeldingDetectionReq(WeldingDetectionReq::decode_body(&mut d)?),
            219 => Self::WeldingDetectionRes(WeldingDetectionRes::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(AC_EVChargeParameter) … 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 ACEVSEChargeParameter {
    /// Fragment event code of `AC_EVSEChargeParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 1;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(AC_EVSEChargeParameter) … 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 AuthorizationReq {
    /// Fragment event code of `AuthorizationReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 4;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(AuthorizationReq) … 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 AuthorizationRes {
    /// Fragment event code of `AuthorizationRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 5;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(AuthorizationRes) … 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 Body {
    /// Fragment event code of `Body` in this schema set.
    pub const FRAGMENT_CODE: u64 = 6;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Body) … 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 BodyBase {
    /// Fragment event code of `BodyElement` in this schema set.
    pub const FRAGMENT_CODE: u64 = 7;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(BodyElement) … 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 CableCheckReq {
    /// Fragment event code of `CableCheckReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 11;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CableCheckReq) … 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 CableCheckRes {
    /// Fragment event code of `CableCheckRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 12;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CableCheckRes) … 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 CanonicalizationMethod {
    /// Fragment event code of `CanonicalizationMethod` in this schema set.
    pub const FRAGMENT_CODE: u64 = 13;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CanonicalizationMethod) … 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 CanonicalizationMethod {
    /// Fragment event code of `CanonicalizationMethod` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 0;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(CanonicalizationMethod) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CertificateInstallationReq) … 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 CertificateInstallationRes {
    /// Fragment event code of `CertificateInstallationRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 16;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CertificateInstallationRes) … 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 CertificateUpdateReq {
    /// Fragment event code of `CertificateUpdateReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 17;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CertificateUpdateReq) … 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 CertificateUpdateRes {
    /// Fragment event code of `CertificateUpdateRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 18;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CertificateUpdateRes) … 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 ChargeParameterDiscoveryReq {
    /// Fragment event code of `ChargeParameterDiscoveryReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 19;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(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 ChargeParameterDiscoveryRes {
    /// Fragment event code of `ChargeParameterDiscoveryRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 20;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(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 ChargeService {
    /// Fragment event code of `ChargeService` in this schema set.
    pub const FRAGMENT_CODE: u64 = 22;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ChargeService) … 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 ChargingProfile {
    /// Fragment event code of `ChargingProfile` in this schema set.
    pub const FRAGMENT_CODE: u64 = 25;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ChargingProfile) … 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 ChargingStatusReq {
    /// Fragment event code of `ChargingStatusReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 30;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ChargingStatusReq) … 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 ChargingStatusRes {
    /// Fragment event code of `ChargingStatusRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 31;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ChargingStatusRes) … 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 ConsumptionCost {
    /// Fragment event code of `ConsumptionCost` in this schema set.
    pub const FRAGMENT_CODE: u64 = 32;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ConsumptionCost) … 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 ContractSignatureEncryptedPrivateKey {
    /// Fragment event code of `ContractSignatureEncryptedPrivateKey` in this schema set.
    pub const FRAGMENT_CODE: u64 = 34;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ContractSignatureEncryptedPrivateKey) … 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 Cost {
    /// Fragment event code of `Cost` in this schema set.
    pub const FRAGMENT_CODE: u64 = 35;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Cost) … 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 CurrentDemandReq {
    /// Fragment event code of `CurrentDemandReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 36;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CurrentDemandReq) … 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 CurrentDemandRes {
    /// Fragment event code of `CurrentDemandRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 37;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(CurrentDemandRes) … 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 DCEVChargeParameter {
    /// Fragment event code of `DC_EVChargeParameter` 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(DC_EVChargeParameter) … 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 DCEVPowerDeliveryParameter {
    /// Fragment event code of `DC_EVPowerDeliveryParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 39;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_EVPowerDeliveryParameter) … 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 DCEVSEChargeParameter {
    /// Fragment event code of `DC_EVSEChargeParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 40;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_EVSEChargeParameter) … 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 DiffieHellmanPublickey {
    /// Fragment event code of `DHpublickey` in this schema set.
    pub const FRAGMENT_CODE: u64 = 45;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DHpublickey) … 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 DigestMethod {
    /// Fragment event code of `DigestMethod` in this schema set.
    pub const FRAGMENT_CODE: u64 = 48;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DigestMethod) … 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 DigestMethod {
    /// Fragment event code of `DigestMethod` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 2;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(DigestMethod) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(EVChargeParameter) … 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 EVPowerDeliveryParameter {
    /// Fragment event code of `EVPowerDeliveryParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 66;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(EVPowerDeliveryParameter) … 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 EVSEChargeParameter {
    /// Fragment event code of `EVSEChargeParameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 69;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(EVSEChargeParameter) … 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 EVSEStatus {
    /// Fragment event code of `EVSEStatus` in this schema set.
    pub const FRAGMENT_CODE: u64 = 92;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(EVSEStatus) … 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 EVStatus {
    /// Fragment event code of `EVStatus` in this schema set.
    pub const FRAGMENT_CODE: u64 = 96;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(EVStatus) … 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 Entry {
    /// Fragment event code of `Entry` in this schema set.
    pub const FRAGMENT_CODE: u64 = 100;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Entry) … 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 MessageHeader {
    /// Fragment event code of `Header` 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(Header) … 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 ListOfRootCertificateIDs {
    /// Fragment event code of `ListOfRootCertificateIDs` in this schema set.
    pub const FRAGMENT_CODE: u64 = 114;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ListOfRootCertificateIDs) … 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 Manifest {
    /// Fragment event code of `Manifest` in this schema set.
    pub const FRAGMENT_CODE: u64 = 115;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Manifest) … 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 Manifest {
    /// Fragment event code of `Manifest` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 11;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(Manifest) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(MeterInfo) … 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 MeteringReceiptReq {
    /// Fragment event code of `MeteringReceiptReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 121;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(MeteringReceiptReq) … 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 MeteringReceiptRes {
    /// Fragment event code of `MeteringReceiptRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 122;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(MeteringReceiptRes) … 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 Notification {
    /// Fragment event code of `Notification` in this schema set.
    pub const FRAGMENT_CODE: u64 = 126;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Notification) … 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 PMaxSchedule {
    /// Fragment event code of `PMaxSchedule` in this schema set.
    pub const FRAGMENT_CODE: u64 = 136;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PMaxSchedule) … 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 PMaxScheduleEntry {
    /// Fragment event code of `PMaxScheduleEntry` in this schema set.
    pub const FRAGMENT_CODE: u64 = 137;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PMaxScheduleEntry) … 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 Parameter {
    /// Fragment event code of `Parameter` in this schema set.
    pub const FRAGMENT_CODE: u64 = 138;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Parameter) … 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 ParameterSet {
    /// Fragment event code of `ParameterSet` in this schema set.
    pub const FRAGMENT_CODE: u64 = 139;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ParameterSet) … 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 PaymentDetailsReq {
    /// Fragment event code of `PaymentDetailsReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 141;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PaymentDetailsReq) … 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 PaymentDetailsRes {
    /// Fragment event code of `PaymentDetailsRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 142;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PaymentDetailsRes) … 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 PaymentOptionList {
    /// Fragment event code of `PaymentOptionList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 144;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PaymentOptionList) … 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 PaymentServiceSelectionReq {
    /// Fragment event code of `PaymentServiceSelectionReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 145;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PaymentServiceSelectionReq) … 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 PaymentServiceSelectionRes {
    /// Fragment event code of `PaymentServiceSelectionRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 146;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PaymentServiceSelectionRes) … 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 PowerDeliveryReq {
    /// Fragment event code of `PowerDeliveryReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 148;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PowerDeliveryReq) … 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 PowerDeliveryRes {
    /// Fragment event code of `PowerDeliveryRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 149;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PowerDeliveryRes) … 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 PreChargeReq {
    /// Fragment event code of `PreChargeReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 150;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PreChargeReq) … 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 PreChargeRes {
    /// Fragment event code of `PreChargeRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 151;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(PreChargeRes) … 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 ProfileEntry {
    /// Fragment event code of `ProfileEntry` in this schema set.
    pub const FRAGMENT_CODE: u64 = 152;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ProfileEntry) … 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 RSAKeyValue {
    /// Fragment event code of `RSAKeyValue` in this schema set.
    pub const FRAGMENT_CODE: u64 = 155;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(RSAKeyValue) … 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 RSAKeyValue {
    /// Fragment event code of `RSAKeyValue` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 21;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(RSAKeyValue) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

impl Reference {
    /// Fragment event code of `Reference` 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(Reference) … 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 Reference {
    /// Fragment event code of `Reference` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 22;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(Reference) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(RelativeTimeInterval) … 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 RetrievalMethod {
    /// Fragment event code of `RetrievalMethod` in this schema set.
    pub const FRAGMENT_CODE: u64 = 163;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(RetrievalMethod) … 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 RetrievalMethod {
    /// Fragment event code of `RetrievalMethod` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 23;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(RetrievalMethod) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

impl SAScheduleList {
    /// Fragment event code of `SAScheduleList` 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(SAScheduleList) … 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 SAScheduleTuple {
    /// Fragment event code of `SAScheduleTuple` 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(SAScheduleTuple) … 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 SASchedules {
    /// Fragment event code of `SASchedules` in this schema set.
    pub const FRAGMENT_CODE: u64 = 171;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SASchedules) … 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 SalesTariff {
    /// Fragment event code of `SalesTariff` 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(SalesTariff) … 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 SalesTariffEntry {
    /// Fragment event code of `SalesTariffEntry` 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(SalesTariffEntry) … 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 SelectedService {
    /// Fragment event code of `SelectedService` in this schema set.
    pub const FRAGMENT_CODE: u64 = 180;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SelectedService) … 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 SelectedServiceList {
    /// Fragment event code of `SelectedServiceList` 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(SelectedServiceList) … 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 Service {
    /// Fragment event code of `Service` 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(Service) … 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 ServiceDetailReq {
    /// Fragment event code of `ServiceDetailReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 185;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ServiceDetailReq) … 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 ServiceDetailRes {
    /// Fragment event code of `ServiceDetailRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 186;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ServiceDetailRes) … 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 ServiceDiscoveryReq {
    /// Fragment event code of `ServiceDiscoveryReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 187;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ServiceDiscoveryReq) … 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 ServiceDiscoveryRes {
    /// Fragment event code of `ServiceDiscoveryRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 188;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ServiceDiscoveryRes) … 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 ServiceList {
    /// Fragment event code of `ServiceList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 191;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ServiceList) … 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 ServiceParameterList {
    /// Fragment event code of `ServiceParameterList` in this schema set.
    pub const FRAGMENT_CODE: u64 = 193;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(ServiceParameterList) … 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 SessionSetupReq {
    /// Fragment event code of `SessionSetupReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 198;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SessionSetupReq) … 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 SessionSetupRes {
    /// Fragment event code of `SessionSetupRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 199;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SessionSetupRes) … 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 SessionStopReq {
    /// Fragment event code of `SessionStopReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 200;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SessionStopReq) … 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 SessionStopRes {
    /// Fragment event code of `SessionStopRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 201;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SessionStopRes) … 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 Signature {
    /// Fragment event code of `Signature` in this schema set.
    pub const FRAGMENT_CODE: u64 = 203;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Signature) … 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 Signature {
    /// Fragment event code of `Signature` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 27;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(Signature) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SignatureMethod) … 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 SignatureMethod {
    /// Fragment event code of `SignatureMethod` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 28;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(SignatureMethod) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SignatureValue) … 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 SignatureValue {
    /// Fragment event code of `SignatureValue` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 31;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(SignatureValue) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SignedInfo) … 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 SignedInfo {
    /// Fragment event code of `SignedInfo` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 32;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(SignedInfo) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SubCertificates) … 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 SupportedEnergyTransferMode {
    /// Fragment event code of `SupportedEnergyTransferMode` in this schema set.
    pub const FRAGMENT_CODE: u64 = 210;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(SupportedEnergyTransferMode) … 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 Interval {
    /// Fragment event code of `TimeInterval` in this schema set.
    pub const FRAGMENT_CODE: u64 = 212;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(TimeInterval) … 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 Transform {
    /// Fragment event code of `Transform` in this schema set.
    pub const FRAGMENT_CODE: u64 = 213;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Transform) … 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 Transform {
    /// Fragment event code of `Transform` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 33;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(Transform) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Transforms) … 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 Transforms {
    /// Fragment event code of `Transforms` in the xmldsig schema alone (ISO 15118-2 Annex J).
    pub const XMLDSIG_FRAGMENT_CODE: u64 = 34;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against the xmldsig schema alone (ISO 15118-2 Annex J).
    ///
    /// A fragment is `SD SE(Transforms) … 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_xmldsig_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::XMLDSIG_FRAGMENT_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(XMLDSIG_FRAGMENT_ED_CODE, XMLDSIG_FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(V2G_Message) … 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 WeldingDetectionReq {
    /// Fragment event code of `WeldingDetectionReq` in this schema set.
    pub const FRAGMENT_CODE: u64 = 218;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WeldingDetectionReq) … 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 WeldingDetectionRes {
    /// Fragment event code of `WeldingDetectionRes` in this schema set.
    pub const FRAGMENT_CODE: u64 = 219;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(WeldingDetectionRes) … 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)
    }
}