iso15118 0.3.0

// @generated by iso15118-codegen. Do not edit.
//
// Source schemas: V2G_CI_CommonTypes.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_CommonTypes";

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

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

impl CLReqControlMode {
    /// 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 CLReqControlMode {
    /// 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 {})
    }
}

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

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

impl CLResControlMode {
    /// 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 CLResControlMode {
    /// 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 {})
    }
}

/// `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(2), 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(2), 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)? })
    }
}

/// `ChargeLoopReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargeLoopReq {
    /// `Header` element, 1..1.
    pub header: MessageHeader,
    /// `DisplayParameters` element, 0..1.
    pub display_parameters: Option<DisplayParameters>,
    /// `MeterInfoRequested` element, 1..1.
    pub meter_info_requested: bool,
}

impl ChargeLoopReq {
    /// 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 ChargeLoopReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // DisplayParameters (0..1)
        if let Some(item) = &self.display_parameters {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // MeterInfoRequested (1..1)
        {
            let item = &self.meter_info_requested;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargeLoopReq {
    /// 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 = MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = DisplayParameters::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            display_parameters: f_1,
            meter_info_requested: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ChargeLoopResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargeLoopRes {
    /// `Header` element, 1..1.
    pub header: MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: ResponseCode,
    /// `EVSEStatus` element, 0..1.
    pub evse_status: Option<EVSEStatus>,
    /// `MeterInfo` element, 0..1.
    pub meter_info: Option<MeterInfo>,
    /// `Receipt` element, 0..1.
    pub receipt: Option<Receipt>,
}

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

impl ChargeLoopRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEStatus (0..1)
        if let Some(item) = &self.evse_status {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // MeterInfo (0..1)
        if let Some(item) = &self.meter_info {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // Receipt (0..1)
        if let Some(item) = &self.receipt {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargeLoopRes {
    /// 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, .. } => {
                    let value = MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = EVSEStatus::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = MeterInfo::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = Receipt::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            evse_status: f_2,
            meter_info: f_3,
            receipt: f_4,
        })
    }
}

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

impl ChargeParameterDiscoveryReq {
    /// 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 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);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { header: f_0.ok_or(ExiError::MissingElement)? })
    }
}

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

impl ChargeParameterDiscoveryRes {
    /// 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 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);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 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;
        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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ResponseCode::from_index(d.nbit(ResponseCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DetailedCostType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DetailedCost {
    /// `Amount` element, 1..1.
    pub amount: RationalNumber,
    /// `CostPerUnit` element, 1..1.
    pub cost_per_unit: RationalNumber,
}

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

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

/// `DetailedTaxType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DetailedTax {
    /// `TaxRuleID` element, 1..1.
    pub tax_rule_id: u32,
    /// `Amount` element, 1..1.
    pub amount: RationalNumber,
}

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

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

/// `DisplayParametersType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DisplayParameters {
    /// `PresentSOC` element, 0..1.
    pub present_soc: Option<u8>,
    /// `MinimumSOC` element, 0..1.
    pub minimum_soc: Option<u8>,
    /// `TargetSOC` element, 0..1.
    pub target_soc: Option<u8>,
    /// `MaximumSOC` element, 0..1.
    pub maximum_soc: Option<u8>,
    /// `RemainingTimeToMinimumSOC` element, 0..1.
    pub remaining_time_to_minimum_soc: Option<u32>,
    /// `RemainingTimeToTargetSOC` element, 0..1.
    pub remaining_time_to_target_soc: Option<u32>,
    /// `RemainingTimeToMaximumSOC` element, 0..1.
    pub remaining_time_to_maximum_soc: Option<u32>,
    /// `ChargingComplete` element, 0..1.
    pub charging_complete: Option<bool>,
    /// `BatteryEnergyCapacity` element, 0..1.
    pub battery_energy_capacity: Option<RationalNumber>,
    /// `InletHot` element, 0..1.
    pub inlet_hot: Option<bool>,
}

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

impl DisplayParameters {
    /// 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);
        // PresentSOC (0..1)
        if let Some(item) = &self.present_soc {
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // MinimumSOC (0..1)
        if let Some(item) = &self.minimum_soc {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // TargetSOC (0..1)
        if let Some(item) = &self.target_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);
        }
        // MaximumSOC (0..1)
        if let Some(item) = &self.maximum_soc {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // RemainingTimeToMinimumSOC (0..1)
        if let Some(item) = &self.remaining_time_to_minimum_soc {
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // RemainingTimeToTargetSOC (0..1)
        if let Some(item) = &self.remaining_time_to_target_soc {
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // RemainingTimeToMaximumSOC (0..1)
        if let Some(item) = &self.remaining_time_to_maximum_soc {
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // ChargingComplete (0..1)
        if let Some(item) = &self.charging_complete {
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 1);
        }
        // BatteryEnergyCapacity (0..1)
        if let Some(item) = &self.battery_energy_capacity {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // InletHot (0..1)
        if let Some(item) = &self.inlet_hot {
            w.start(e, 9, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(9, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DisplayParameters {
    /// 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, .. } => {
                    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_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    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_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 { index: 3, .. } => {
                    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_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    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_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    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_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    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_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_9 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            present_soc: f_0,
            minimum_soc: f_1,
            target_soc: f_2,
            maximum_soc: f_3,
            remaining_time_to_minimum_soc: f_4,
            remaining_time_to_target_soc: f_5,
            remaining_time_to_maximum_soc: f_6,
            charging_complete: f_7,
            battery_energy_capacity: f_8,
            inlet_hot: f_9,
        })
    }
}

/// `Dynamic_CLReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DynamicCLReqControlMode {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `EVTargetEnergyRequest` element, 1..1.
    pub ev_target_energy_request: RationalNumber,
    /// `EVMaximumEnergyRequest` element, 1..1.
    pub ev_maximum_energy_request: RationalNumber,
    /// `EVMinimumEnergyRequest` element, 1..1.
    pub ev_minimum_energy_request: RationalNumber,
}

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

impl DynamicCLReqControlMode {
    /// 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);
        }
        // EVTargetEnergyRequest (1..1)
        {
            let item = &self.ev_target_energy_request;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMaximumEnergyRequest (1..1)
        {
            let item = &self.ev_maximum_energy_request;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVMinimumEnergyRequest (1..1)
        {
            let item = &self.ev_minimum_energy_request;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DynamicCLReqControlMode {
    /// 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 = 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 = RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            departure_time: f_0,
            ev_target_energy_request: f_1.ok_or(ExiError::MissingElement)?,
            ev_maximum_energy_request: f_2.ok_or(ExiError::MissingElement)?,
            ev_minimum_energy_request: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `Dynamic_CLResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DynamicCLResControlMode {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `MinimumSOC` element, 0..1.
    pub minimum_soc: Option<u8>,
    /// `TargetSOC` element, 0..1.
    pub target_soc: Option<u8>,
    /// `AckMaxDelay` element, 0..1.
    pub ack_max_delay: Option<u16>,
}

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

impl DynamicCLResControlMode {
    /// 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);
        }
        // MinimumSOC (0..1)
        if let Some(item) = &self.minimum_soc {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // TargetSOC (0..1)
        if let Some(item) = &self.target_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);
        }
        // AckMaxDelay (0..1)
        if let Some(item) = &self.ack_max_delay {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DynamicCLResControlMode {
    /// 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 = 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 = u8::try_from(d.restricted(0, 100)?)
                        .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 = u8::try_from(d.restricted(0, 100)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { departure_time: f_0, minimum_soc: f_1, target_soc: f_2, ack_max_delay: f_3 })
    }
}

/// `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)?,
        })
    }
}

/// `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(26), 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(26), 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>,
    /// `TimeStamp` element, 1..1.
    pub time_stamp: u64,
    /// `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, 1, 2, 1],
        repeat_width: &[0, 0, 0],
        min: &[1, 1, 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::exact(8))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // TimeStamp (1..1)
        {
            let item = &self.time_stamp;
            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);
        }
        // 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::exact(8))?;
                    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, .. } => {
                    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)?,
            time_stamp: f_1.ok_or(ExiError::MissingElement)?,
            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,
    /// `ChargedEnergyReadingWh` element, 1..1.
    pub charged_energy_reading_wh: u64,
    /// `BPT_DischargedEnergyReadingWh` element, 0..1.
    pub bpt_discharged_energy_reading_wh: Option<u64>,
    /// `CapacitiveEnergyReadingVARh` element, 0..1.
    pub capacitive_energy_reading_va_rh: Option<u64>,
    /// `BPT_InductiveEnergyReadingVARh` element, 0..1.
    pub bpt_inductive_energy_reading_va_rh: Option<u64>,
    /// `MeterSignature` element, 0..1.
    pub meter_signature: Option<Vec<u8>>,
    /// `MeterStatus` element, 0..1.
    pub meter_status: Option<i16>,
    /// `MeterTimestamp` element, 0..1.
    pub meter_timestamp: Option<u64>,
}

impl MeterInfo {
    /// Event-code arithmetic of this type's content model.
    const SHAPE: Shape = Shape {
        prod_before: &[0, 1, 2, 3, 4, 5, 6, 7, 8],
        width: &[1, 1, 3, 3, 3, 3, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0],
        min: &[1, 1, 0, 0, 0, 0, 0, 0],
        max: &[1, 1, 1, 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(30), item, Lengths::max(32))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // ChargedEnergyReadingWh (1..1)
        {
            let item = &self.charged_energy_reading_wh;
            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);
        }
        // BPT_DischargedEnergyReadingWh (0..1)
        if let Some(item) = &self.bpt_discharged_energy_reading_wh {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // CapacitiveEnergyReadingVARh (0..1)
        if let Some(item) = &self.capacitive_energy_reading_va_rh {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // BPT_InductiveEnergyReadingVARh (0..1)
        if let Some(item) = &self.bpt_inductive_energy_reading_va_rh {
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // MeterSignature (0..1)
        if let Some(item) = &self.meter_signature {
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(64))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // MeterStatus (0..1)
        if let Some(item) = &self.meter_status {
            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);
        }
        // MeterTimestamp (0..1)
        if let Some(item) = &self.meter_timestamp {
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 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;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = 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(30), 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 = u64::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u64::try_from(d.uint()?).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 = u64::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    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.binary(Lengths::max(64))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    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 { index: 7, .. } => {
                    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_7 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            meter_id: f_0.ok_or(ExiError::MissingElement)?,
            charged_energy_reading_wh: f_1.ok_or(ExiError::MissingElement)?,
            bpt_discharged_energy_reading_wh: f_2,
            capacitive_energy_reading_va_rh: f_3,
            bpt_inductive_energy_reading_va_rh: f_4,
            meter_signature: f_5,
            meter_status: f_6,
            meter_timestamp: f_7,
        })
    }
}

/// `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)?,
        })
    }
}

/// `RationalNumberType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RationalNumber {
    /// `Exponent` element, 1..1.
    pub exponent: i8,
    /// `Value` element, 1..1.
    pub value: i16,
}

impl RationalNumber {
    /// 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 RationalNumber {
    /// 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);
        // Exponent (1..1)
        {
            let item = &self.exponent;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), -128, 127)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // Value (1..1)
        {
            let item = &self.value;
            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 RationalNumber {
    /// 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 = i8::try_from(d.restricted(-128, 127)?)
                        .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 = 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 {
            exponent: f_0.ok_or(ExiError::MissingElement)?,
            value: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ReceiptType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Receipt {
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `EnergyCosts` element, 0..1.
    pub energy_costs: Option<DetailedCost>,
    /// `OccupancyCosts` element, 0..1.
    pub occupancy_costs: Option<DetailedCost>,
    /// `AdditionalServicesCosts` element, 0..1.
    pub additional_services_costs: Option<DetailedCost>,
    /// `OverstayCosts` element, 0..1.
    pub overstay_costs: Option<DetailedCost>,
    /// `TaxCosts` element, 0..10.
    pub tax_costs: Vec<DetailedTax>,
}

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

impl Receipt {
    /// 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);
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            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);
        }
        // EnergyCosts (0..1)
        if let Some(item) = &self.energy_costs {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // OccupancyCosts (0..1)
        if let Some(item) = &self.occupancy_costs {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // AdditionalServicesCosts (0..1)
        if let Some(item) = &self.additional_services_costs {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // OverstayCosts (0..1)
        if let Some(item) = &self.overstay_costs {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // TaxCosts (0..10)
        {
            let items = &self.tax_costs;
            let count = items.len() as u32;
            if count > 10 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 5, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(5, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Receipt {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = Vec::new();
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    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_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = DetailedCost::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = DetailedCost::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = DetailedCost::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = DetailedCost::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = DetailedTax::decode_body(d)?;
                    f_5.push(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            time_anchor: f_0.ok_or(ExiError::MissingElement)?,
            energy_costs: f_1,
            occupancy_costs: f_2,
            additional_services_costs: f_3,
            overstay_costs: f_4,
            tax_costs: f_5,
        })
    }
}

/// `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(26), 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(62), 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(63), 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(26), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.string(ValueCtx(62), Lengths::max(65536))?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = d.string(ValueCtx(63), 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)?,
        })
    }
}

/// `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(62), 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(63), 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(62), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = d.string(ValueCtx(63), 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 })
    }
}

/// `Scheduled_CLReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledCLReqControlMode {
    /// `EVTargetEnergyRequest` element, 0..1.
    pub ev_target_energy_request: Option<RationalNumber>,
    /// `EVMaximumEnergyRequest` element, 0..1.
    pub ev_maximum_energy_request: Option<RationalNumber>,
    /// `EVMinimumEnergyRequest` element, 0..1.
    pub ev_minimum_energy_request: Option<RationalNumber>,
}

impl ScheduledCLReqControlMode {
    /// 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 ScheduledCLReqControlMode {
    /// 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);
        // EVTargetEnergyRequest (0..1)
        if let Some(item) = &self.ev_target_energy_request {
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVMaximumEnergyRequest (0..1)
        if let Some(item) = &self.ev_maximum_energy_request {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMinimumEnergyRequest (0..1)
        if let Some(item) = &self.ev_minimum_energy_request {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ScheduledCLReqControlMode {
    /// 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 = RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ev_target_energy_request: f_0,
            ev_maximum_energy_request: f_1,
            ev_minimum_energy_request: f_2,
        })
    }
}

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

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

impl ScheduledCLResControlMode {
    /// 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 ScheduledCLResControlMode {
    /// 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 {})
    }
}

/// `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(2), 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(2), 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(26), 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(26), 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(26), 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(26), 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(26), 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(26), 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
            },
        })
    }
}

/// `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(2), 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(2), 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
            },
        })
    }
}

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

impl V2GMessage {
    /// 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 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);
        }
        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;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { header: f_0.ok_or(ExiError::MissingElement)? })
    }
}

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

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

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

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

impl V2GResponse {
    /// 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 V2GResponse {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `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(65), 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(65), 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)?,
        })
    }
}

/// `evseNotificationType`.
///
/// 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 EvseNotification {
    /// `Pause`
    Pause = 0,
    /// `ExitStandby`
    ExitStandby = 1,
    /// `Terminate`
    Terminate = 2,
    /// `ScheduleRenegotiation`
    ScheduleRenegotiation = 3,
    /// `ServiceRenegotiation`
    ServiceRenegotiation = 4,
    /// `MeteringConfirmation`
    MeteringConfirmation = 5,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 6] = [
        Self::Pause,
        Self::ExitStandby,
        Self::Terminate,
        Self::ScheduleRenegotiation,
        Self::ServiceRenegotiation,
        Self::MeteringConfirmation,
    ];

    /// 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::Pause,
            1 => Self::ExitStandby,
            2 => Self::Terminate,
            3 => Self::ScheduleRenegotiation,
            4 => Self::ServiceRenegotiation,
            5 => Self::MeteringConfirmation,
            _ => 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::Pause => "Pause",
            Self::ExitStandby => "ExitStandby",
            Self::Terminate => "Terminate",
            Self::ScheduleRenegotiation => "ScheduleRenegotiation",
            Self::ServiceRenegotiation => "ServiceRenegotiation",
            Self::MeteringConfirmation => "MeteringConfirmation",
        }
    }
}

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

impl Processing {
    /// 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",
        }
    }
}

/// `responseCodeType`.
///
/// 40 values, so 6 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_CertificateExpiresSoon`
    OKCertificateExpiresSoon = 1,
    /// `OK_NewSessionEstablished`
    OKNewSessionEstablished = 2,
    /// `OK_OldSessionJoined`
    OKOldSessionJoined = 3,
    /// `OK_PowerToleranceConfirmed`
    OKPowerToleranceConfirmed = 4,
    /// `WARNING_AuthorizationSelectionInvalid`
    WARNINGAuthorizationSelectionInvalid = 5,
    /// `WARNING_CertificateExpired`
    WARNINGCertificateExpired = 6,
    /// `WARNING_CertificateNotYetValid`
    WARNINGCertificateNotYetValid = 7,
    /// `WARNING_CertificateRevoked`
    WARNINGCertificateRevoked = 8,
    /// `WARNING_CertificateValidationError`
    WARNINGCertificateValidationError = 9,
    /// `WARNING_ChallengeInvalid`
    WARNINGChallengeInvalid = 10,
    /// `WARNING_EIMAuthorizationFailure`
    WARNINGEIMAuthorizationFailure = 11,
    /// `WARNING_eMSPUnknown`
    WARNINGEMSPUnknown = 12,
    /// `WARNING_EVPowerProfileViolation`
    WARNINGEVPowerProfileViolation = 13,
    /// `WARNING_GeneralPnCAuthorizationError`
    WARNINGGeneralPnCAuthorizationError = 14,
    /// `WARNING_NoCertificateAvailable`
    WARNINGNoCertificateAvailable = 15,
    /// `WARNING_NoContractMatchingPCIDFound`
    WARNINGNoContractMatchingPCIDFound = 16,
    /// `WARNING_PowerToleranceNotConfirmed`
    WARNINGPowerToleranceNotConfirmed = 17,
    /// `WARNING_ScheduleRenegotiationFailed`
    WARNINGScheduleRenegotiationFailed = 18,
    /// `WARNING_StandbyNotAllowed`
    WARNINGStandbyNotAllowed = 19,
    /// `WARNING_WPT`
    WARNINGWPT = 20,
    /// `FAILED`
    FAILED = 21,
    /// `FAILED_AssociationError`
    FAILEDAssociationError = 22,
    /// `FAILED_ContactorError`
    FAILEDContactorError = 23,
    /// `FAILED_EVPowerProfileInvalid`
    FAILEDEVPowerProfileInvalid = 24,
    /// `FAILED_EVPowerProfileViolation`
    FAILEDEVPowerProfileViolation = 25,
    /// `FAILED_MeteringSignatureNotValid`
    FAILEDMeteringSignatureNotValid = 26,
    /// `FAILED_NoEnergyTransferServiceSelected`
    FAILEDNoEnergyTransferServiceSelected = 27,
    /// `FAILED_NoServiceRenegotiationSupported`
    FAILEDNoServiceRenegotiationSupported = 28,
    /// `FAILED_PauseNotAllowed`
    FAILEDPauseNotAllowed = 29,
    /// `FAILED_PowerDeliveryNotApplied`
    FAILEDPowerDeliveryNotApplied = 30,
    /// `FAILED_PowerToleranceNotConfirmed`
    FAILEDPowerToleranceNotConfirmed = 31,
    /// `FAILED_ScheduleRenegotiation`
    FAILEDScheduleRenegotiation = 32,
    /// `FAILED_ScheduleSelectionInvalid`
    FAILEDScheduleSelectionInvalid = 33,
    /// `FAILED_SequenceError`
    FAILEDSequenceError = 34,
    /// `FAILED_ServiceIDInvalid`
    FAILEDServiceIDInvalid = 35,
    /// `FAILED_ServiceSelectionInvalid`
    FAILEDServiceSelectionInvalid = 36,
    /// `FAILED_SignatureError`
    FAILEDSignatureError = 37,
    /// `FAILED_UnknownSession`
    FAILEDUnknownSession = 38,
    /// `FAILED_WrongChargeParameter`
    FAILEDWrongChargeParameter = 39,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 40] = [
        Self::OK,
        Self::OKCertificateExpiresSoon,
        Self::OKNewSessionEstablished,
        Self::OKOldSessionJoined,
        Self::OKPowerToleranceConfirmed,
        Self::WARNINGAuthorizationSelectionInvalid,
        Self::WARNINGCertificateExpired,
        Self::WARNINGCertificateNotYetValid,
        Self::WARNINGCertificateRevoked,
        Self::WARNINGCertificateValidationError,
        Self::WARNINGChallengeInvalid,
        Self::WARNINGEIMAuthorizationFailure,
        Self::WARNINGEMSPUnknown,
        Self::WARNINGEVPowerProfileViolation,
        Self::WARNINGGeneralPnCAuthorizationError,
        Self::WARNINGNoCertificateAvailable,
        Self::WARNINGNoContractMatchingPCIDFound,
        Self::WARNINGPowerToleranceNotConfirmed,
        Self::WARNINGScheduleRenegotiationFailed,
        Self::WARNINGStandbyNotAllowed,
        Self::WARNINGWPT,
        Self::FAILED,
        Self::FAILEDAssociationError,
        Self::FAILEDContactorError,
        Self::FAILEDEVPowerProfileInvalid,
        Self::FAILEDEVPowerProfileViolation,
        Self::FAILEDMeteringSignatureNotValid,
        Self::FAILEDNoEnergyTransferServiceSelected,
        Self::FAILEDNoServiceRenegotiationSupported,
        Self::FAILEDPauseNotAllowed,
        Self::FAILEDPowerDeliveryNotApplied,
        Self::FAILEDPowerToleranceNotConfirmed,
        Self::FAILEDScheduleRenegotiation,
        Self::FAILEDScheduleSelectionInvalid,
        Self::FAILEDSequenceError,
        Self::FAILEDServiceIDInvalid,
        Self::FAILEDServiceSelectionInvalid,
        Self::FAILEDSignatureError,
        Self::FAILEDUnknownSession,
        Self::FAILEDWrongChargeParameter,
    ];

    /// 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::OKCertificateExpiresSoon,
            2 => Self::OKNewSessionEstablished,
            3 => Self::OKOldSessionJoined,
            4 => Self::OKPowerToleranceConfirmed,
            5 => Self::WARNINGAuthorizationSelectionInvalid,
            6 => Self::WARNINGCertificateExpired,
            7 => Self::WARNINGCertificateNotYetValid,
            8 => Self::WARNINGCertificateRevoked,
            9 => Self::WARNINGCertificateValidationError,
            10 => Self::WARNINGChallengeInvalid,
            11 => Self::WARNINGEIMAuthorizationFailure,
            12 => Self::WARNINGEMSPUnknown,
            13 => Self::WARNINGEVPowerProfileViolation,
            14 => Self::WARNINGGeneralPnCAuthorizationError,
            15 => Self::WARNINGNoCertificateAvailable,
            16 => Self::WARNINGNoContractMatchingPCIDFound,
            17 => Self::WARNINGPowerToleranceNotConfirmed,
            18 => Self::WARNINGScheduleRenegotiationFailed,
            19 => Self::WARNINGStandbyNotAllowed,
            20 => Self::WARNINGWPT,
            21 => Self::FAILED,
            22 => Self::FAILEDAssociationError,
            23 => Self::FAILEDContactorError,
            24 => Self::FAILEDEVPowerProfileInvalid,
            25 => Self::FAILEDEVPowerProfileViolation,
            26 => Self::FAILEDMeteringSignatureNotValid,
            27 => Self::FAILEDNoEnergyTransferServiceSelected,
            28 => Self::FAILEDNoServiceRenegotiationSupported,
            29 => Self::FAILEDPauseNotAllowed,
            30 => Self::FAILEDPowerDeliveryNotApplied,
            31 => Self::FAILEDPowerToleranceNotConfirmed,
            32 => Self::FAILEDScheduleRenegotiation,
            33 => Self::FAILEDScheduleSelectionInvalid,
            34 => Self::FAILEDSequenceError,
            35 => Self::FAILEDServiceIDInvalid,
            36 => Self::FAILEDServiceSelectionInvalid,
            37 => Self::FAILEDSignatureError,
            38 => Self::FAILEDUnknownSession,
            39 => Self::FAILEDWrongChargeParameter,
            _ => 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::OKCertificateExpiresSoon => "OK_CertificateExpiresSoon",
            Self::OKNewSessionEstablished => "OK_NewSessionEstablished",
            Self::OKOldSessionJoined => "OK_OldSessionJoined",
            Self::OKPowerToleranceConfirmed => "OK_PowerToleranceConfirmed",
            Self::WARNINGAuthorizationSelectionInvalid => "WARNING_AuthorizationSelectionInvalid",
            Self::WARNINGCertificateExpired => "WARNING_CertificateExpired",
            Self::WARNINGCertificateNotYetValid => "WARNING_CertificateNotYetValid",
            Self::WARNINGCertificateRevoked => "WARNING_CertificateRevoked",
            Self::WARNINGCertificateValidationError => "WARNING_CertificateValidationError",
            Self::WARNINGChallengeInvalid => "WARNING_ChallengeInvalid",
            Self::WARNINGEIMAuthorizationFailure => "WARNING_EIMAuthorizationFailure",
            Self::WARNINGEMSPUnknown => "WARNING_eMSPUnknown",
            Self::WARNINGEVPowerProfileViolation => "WARNING_EVPowerProfileViolation",
            Self::WARNINGGeneralPnCAuthorizationError => "WARNING_GeneralPnCAuthorizationError",
            Self::WARNINGNoCertificateAvailable => "WARNING_NoCertificateAvailable",
            Self::WARNINGNoContractMatchingPCIDFound => "WARNING_NoContractMatchingPCIDFound",
            Self::WARNINGPowerToleranceNotConfirmed => "WARNING_PowerToleranceNotConfirmed",
            Self::WARNINGScheduleRenegotiationFailed => "WARNING_ScheduleRenegotiationFailed",
            Self::WARNINGStandbyNotAllowed => "WARNING_StandbyNotAllowed",
            Self::WARNINGWPT => "WARNING_WPT",
            Self::FAILED => "FAILED",
            Self::FAILEDAssociationError => "FAILED_AssociationError",
            Self::FAILEDContactorError => "FAILED_ContactorError",
            Self::FAILEDEVPowerProfileInvalid => "FAILED_EVPowerProfileInvalid",
            Self::FAILEDEVPowerProfileViolation => "FAILED_EVPowerProfileViolation",
            Self::FAILEDMeteringSignatureNotValid => "FAILED_MeteringSignatureNotValid",
            Self::FAILEDNoEnergyTransferServiceSelected => "FAILED_NoEnergyTransferServiceSelected",
            Self::FAILEDNoServiceRenegotiationSupported => "FAILED_NoServiceRenegotiationSupported",
            Self::FAILEDPauseNotAllowed => "FAILED_PauseNotAllowed",
            Self::FAILEDPowerDeliveryNotApplied => "FAILED_PowerDeliveryNotApplied",
            Self::FAILEDPowerToleranceNotConfirmed => "FAILED_PowerToleranceNotConfirmed",
            Self::FAILEDScheduleRenegotiation => "FAILED_ScheduleRenegotiation",
            Self::FAILEDScheduleSelectionInvalid => "FAILED_ScheduleSelectionInvalid",
            Self::FAILEDSequenceError => "FAILED_SequenceError",
            Self::FAILEDServiceIDInvalid => "FAILED_ServiceIDInvalid",
            Self::FAILEDServiceSelectionInvalid => "FAILED_ServiceSelectionInvalid",
            Self::FAILEDSignatureError => "FAILED_SignatureError",
            Self::FAILEDUnknownSession => "FAILED_UnknownSession",
            Self::FAILEDWrongChargeParameter => "FAILED_WrongChargeParameter",
        }
    }
}

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

    /// 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 {
        matches!(
            self,
            Self::WARNINGAuthorizationSelectionInvalid
                | Self::WARNINGCertificateExpired
                | Self::WARNINGCertificateNotYetValid
                | Self::WARNINGCertificateRevoked
                | Self::WARNINGCertificateValidationError
                | Self::WARNINGChallengeInvalid
                | Self::WARNINGEIMAuthorizationFailure
                | Self::WARNINGEMSPUnknown
                | Self::WARNINGEVPowerProfileViolation
                | Self::WARNINGGeneralPnCAuthorizationError
                | Self::WARNINGNoCertificateAvailable
                | Self::WARNINGNoContractMatchingPCIDFound
                | Self::WARNINGPowerToleranceNotConfirmed
                | Self::WARNINGScheduleRenegotiationFailed
                | Self::WARNINGStandbyNotAllowed
                | Self::WARNINGWPT
        )
    }

    /// 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::FAILEDAssociationError
                | Self::FAILEDContactorError
                | Self::FAILEDEVPowerProfileInvalid
                | Self::FAILEDEVPowerProfileViolation
                | Self::FAILEDMeteringSignatureNotValid
                | Self::FAILEDNoEnergyTransferServiceSelected
                | Self::FAILEDNoServiceRenegotiationSupported
                | Self::FAILEDPauseNotAllowed
                | Self::FAILEDPowerDeliveryNotApplied
                | Self::FAILEDPowerToleranceNotConfirmed
                | Self::FAILEDScheduleRenegotiation
                | Self::FAILEDScheduleSelectionInvalid
                | Self::FAILEDSequenceError
                | Self::FAILEDServiceIDInvalid
                | Self::FAILEDServiceSelectionInvalid
                | Self::FAILEDSignatureError
                | Self::FAILEDUnknownSession
                | Self::FAILEDWrongChargeParameter
        )
    }
}

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

/// 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 — 93 here, against the 26
/// 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 = 7;

/// `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 = 94;

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

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

impl crate::exi::ExiDocument for CLResControlMode {
    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 = 2;
}

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

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

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

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 = 14;
}

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

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

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 = 18;
}

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 = 21;
}

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 = 22;
}

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

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 = 24;
}

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)
    }
}

/// 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 {
    /// `CLReqControlMode`
    CLReqControlMode(CLReqControlMode),
    /// `CLResControlMode`
    CLResControlMode(CLResControlMode),
    /// `CanonicalizationMethod`
    CanonicalizationMethod(CanonicalizationMethod),
    /// `DigestMethod`
    DigestMethod(DigestMethod),
    /// `Manifest`
    Manifest(Manifest),
    /// `RSAKeyValue`
    RSAKeyValue(RSAKeyValue),
    /// `Reference`
    Reference(Reference),
    /// `RetrievalMethod`
    RetrievalMethod(RetrievalMethod),
    /// `Signature`
    Signature(Signature),
    /// `SignatureMethod`
    SignatureMethod(SignatureMethod),
    /// `SignatureValue`
    SignatureValue(SignatureValue),
    /// `SignedInfo`
    SignedInfo(SignedInfo),
    /// `Transform`
    Transform(Transform),
    /// `Transforms`
    Transforms(Transforms),
}

impl Document {
    /// The element name of this document.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::CLReqControlMode(_) => "CLReqControlMode",
            Self::CLResControlMode(_) => "CLResControlMode",
            Self::CanonicalizationMethod(_) => "CanonicalizationMethod",
            Self::DigestMethod(_) => "DigestMethod",
            Self::Manifest(_) => "Manifest",
            Self::RSAKeyValue(_) => "RSAKeyValue",
            Self::Reference(_) => "Reference",
            Self::RetrievalMethod(_) => "RetrievalMethod",
            Self::Signature(_) => "Signature",
            Self::SignatureMethod(_) => "SignatureMethod",
            Self::SignatureValue(_) => "SignatureValue",
            Self::SignedInfo(_) => "SignedInfo",
            Self::Transform(_) => "Transform",
            Self::Transforms(_) => "Transforms",
        }
    }

    /// The document event code of this message.
    #[must_use]
    pub const fn code(&self) -> u64 {
        match self {
            Self::CLReqControlMode(_) => 0,
            Self::CLResControlMode(_) => 1,
            Self::CanonicalizationMethod(_) => 2,
            Self::DigestMethod(_) => 4,
            Self::Manifest(_) => 9,
            Self::RSAKeyValue(_) => 13,
            Self::Reference(_) => 14,
            Self::RetrievalMethod(_) => 15,
            Self::Signature(_) => 17,
            Self::SignatureMethod(_) => 18,
            Self::SignatureValue(_) => 21,
            Self::SignedInfo(_) => 22,
            Self::Transform(_) => 23,
            Self::Transforms(_) => 24,
        }
    }
}

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::CLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::CLResControlMode(m) => m.encode_body(&mut e)?,
            Self::CanonicalizationMethod(m) => m.encode_body(&mut e)?,
            Self::DigestMethod(m) => m.encode_body(&mut e)?,
            Self::Manifest(m) => m.encode_body(&mut e)?,
            Self::RSAKeyValue(m) => m.encode_body(&mut e)?,
            Self::Reference(m) => m.encode_body(&mut e)?,
            Self::RetrievalMethod(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::Transform(m) => m.encode_body(&mut e)?,
            Self::Transforms(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::CLReqControlMode(CLReqControlMode::decode_body(&mut d)?),
            1 => Self::CLResControlMode(CLResControlMode::decode_body(&mut d)?),
            2 => Self::CanonicalizationMethod(CanonicalizationMethod::decode_body(&mut d)?),
            4 => Self::DigestMethod(DigestMethod::decode_body(&mut d)?),
            9 => Self::Manifest(Manifest::decode_body(&mut d)?),
            13 => Self::RSAKeyValue(RSAKeyValue::decode_body(&mut d)?),
            14 => Self::Reference(Reference::decode_body(&mut d)?),
            15 => Self::RetrievalMethod(RetrievalMethod::decode_body(&mut d)?),
            17 => Self::Signature(Signature::decode_body(&mut d)?),
            18 => Self::SignatureMethod(SignatureMethod::decode_body(&mut d)?),
            21 => Self::SignatureValue(SignatureValue::decode_body(&mut d)?),
            22 => Self::SignedInfo(SignedInfo::decode_body(&mut d)?),
            23 => Self::Transform(Transform::decode_body(&mut d)?),
            24 => Self::Transforms(Transforms::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.finish()?;
        Ok(value)
    }
}

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::CLReqControlMode(_) => 6,
            Self::CLResControlMode(_) => 7,
            Self::CanonicalizationMethod(_) => 8,
            Self::DigestMethod(_) => 15,
            Self::Manifest(_) => 34,
            Self::RSAKeyValue(_) => 56,
            Self::Reference(_) => 58,
            Self::RetrievalMethod(_) => 63,
            Self::Signature(_) => 69,
            Self::SignatureMethod(_) => 70,
            Self::SignatureValue(_) => 73,
            Self::SignedInfo(_) => 74,
            Self::Transform(_) => 80,
            Self::Transforms(_) => 81,
        }
    }

    /// 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::CLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::CLResControlMode(m) => m.encode_body(&mut e)?,
            Self::CanonicalizationMethod(m) => m.encode_body(&mut e)?,
            Self::DigestMethod(m) => m.encode_body(&mut e)?,
            Self::Manifest(m) => m.encode_body(&mut e)?,
            Self::RSAKeyValue(m) => m.encode_body(&mut e)?,
            Self::Reference(m) => m.encode_body(&mut e)?,
            Self::RetrievalMethod(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::Transform(m) => m.encode_body(&mut e)?,
            Self::Transforms(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)? {
            6 => Self::CLReqControlMode(CLReqControlMode::decode_body(&mut d)?),
            7 => Self::CLResControlMode(CLResControlMode::decode_body(&mut d)?),
            8 => Self::CanonicalizationMethod(CanonicalizationMethod::decode_body(&mut d)?),
            15 => Self::DigestMethod(DigestMethod::decode_body(&mut d)?),
            34 => Self::Manifest(Manifest::decode_body(&mut d)?),
            56 => Self::RSAKeyValue(RSAKeyValue::decode_body(&mut d)?),
            58 => Self::Reference(Reference::decode_body(&mut d)?),
            63 => Self::RetrievalMethod(RetrievalMethod::decode_body(&mut d)?),
            69 => Self::Signature(Signature::decode_body(&mut d)?),
            70 => Self::SignatureMethod(SignatureMethod::decode_body(&mut d)?),
            73 => Self::SignatureValue(SignatureValue::decode_body(&mut d)?),
            74 => Self::SignedInfo(SignedInfo::decode_body(&mut d)?),
            80 => Self::Transform(Transform::decode_body(&mut d)?),
            81 => Self::Transforms(Transforms::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl CLReqControlMode {
    /// Fragment event code of `CLReqControlMode` 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(CLReqControlMode) … 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 CLResControlMode {
    /// Fragment event code of `CLResControlMode` 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(CLResControlMode) … 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 = 8;

    /// 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 DigestMethod {
    /// Fragment event code of `DigestMethod` 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(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 DisplayParameters {
    /// Fragment event code of `DisplayParameters` 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(DisplayParameters) … 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 = 21;

    /// 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 MessageHeader {
    /// Fragment event code of `Header` in this schema set.
    pub const FRAGMENT_CODE: u64 = 28;

    /// 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 Manifest {
    /// Fragment event code of `Manifest` 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(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 = 37;

    /// 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 RSAKeyValue {
    /// Fragment event code of `RSAKeyValue` in this schema set.
    pub const FRAGMENT_CODE: u64 = 56;

    /// 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 Receipt {
    /// Fragment event code of `Receipt` in this schema set.
    pub const FRAGMENT_CODE: u64 = 57;

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Receipt) … 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 this schema set.
    pub const FRAGMENT_CODE: u64 = 58;

    /// 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 RetrievalMethod {
    /// Fragment event code of `RetrievalMethod` in this schema set.
    pub const FRAGMENT_CODE: u64 = 63;

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

    /// 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 = 73;

    /// 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 = 74;

    /// 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 DetailedTax {
    /// Fragment event code of `TaxCosts` in this schema set.
    pub const FRAGMENT_CODE: u64 = 76;

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

    /// 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 = 81;

    /// 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)
    }
}