iso15118 0.5.0

// @generated by iso15118-codegen. Do not edit.
//
// Source schemas: V2G_CI_CommonTypes.xsd, V2G_CI_DC.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,
    clippy::needless_update
)]

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, ValueCoding, ValueCtx,
};

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

/// `BPT_DC_CPDReqEnergyTransferModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BPTDCCPDReqEnergyTransferMode {
    /// `EVMaximumChargePower` element, 1..1.
    pub ev_maximum_charge_power: super::common::RationalNumber,
    /// `EVMinimumChargePower` element, 1..1.
    pub ev_minimum_charge_power: super::common::RationalNumber,
    /// `EVMaximumChargeCurrent` element, 1..1.
    pub ev_maximum_charge_current: super::common::RationalNumber,
    /// `EVMinimumChargeCurrent` element, 1..1.
    pub ev_minimum_charge_current: super::common::RationalNumber,
    /// `EVMaximumVoltage` element, 1..1.
    pub ev_maximum_voltage: super::common::RationalNumber,
    /// `EVMinimumVoltage` element, 1..1.
    pub ev_minimum_voltage: super::common::RationalNumber,
    /// `TargetSOC` element, 0..1.
    pub target_soc: Option<u8>,
    /// `EVMaximumDischargePower` element, 1..1.
    pub ev_maximum_discharge_power: super::common::RationalNumber,
    /// `EVMinimumDischargePower` element, 1..1.
    pub ev_minimum_discharge_power: super::common::RationalNumber,
    /// `EVMaximumDischargeCurrent` element, 1..1.
    pub ev_maximum_discharge_current: super::common::RationalNumber,
    /// `EVMinimumDischargeCurrent` element, 1..1.
    pub ev_minimum_discharge_current: super::common::RationalNumber,
}

impl BPTDCCPDReqEnergyTransferMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            ev_maximum_charge_power: super::common::RationalNumber::minimal(),
            ev_minimum_charge_power: super::common::RationalNumber::minimal(),
            ev_maximum_charge_current: super::common::RationalNumber::minimal(),
            ev_minimum_charge_current: super::common::RationalNumber::minimal(),
            ev_maximum_voltage: super::common::RationalNumber::minimal(),
            ev_minimum_voltage: super::common::RationalNumber::minimal(),
            target_soc: None,
            ev_maximum_discharge_power: super::common::RationalNumber::minimal(),
            ev_minimum_discharge_power: super::common::RationalNumber::minimal(),
            ev_maximum_discharge_current: super::common::RationalNumber::minimal(),
            ev_minimum_discharge_current: super::common::RationalNumber::minimal(),
        }
    }
}

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

impl BPTDCCPDReqEnergyTransferMode {
    /// 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);
        // EVMaximumChargePower (1..1)
        {
            let item = &self.ev_maximum_charge_power;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVMinimumChargePower (1..1)
        {
            let item = &self.ev_minimum_charge_power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMaximumChargeCurrent (1..1)
        {
            let item = &self.ev_maximum_charge_current;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVMinimumChargeCurrent (1..1)
        {
            let item = &self.ev_minimum_charge_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVMaximumVoltage (1..1)
        {
            let item = &self.ev_maximum_voltage;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMinimumVoltage (1..1)
        {
            let item = &self.ev_minimum_voltage;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // TargetSOC (0..1)
        if let Some(item) = &self.target_soc {
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // EVMaximumDischargePower (1..1)
        {
            let item = &self.ev_maximum_discharge_power;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVMinimumDischargePower (1..1)
        {
            let item = &self.ev_minimum_discharge_power;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVMaximumDischargeCurrent (1..1)
        {
            let item = &self.ev_maximum_discharge_current;
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // EVMinimumDischargeCurrent (1..1)
        {
            let item = &self.ev_minimum_discharge_current;
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BPTDCCPDReqEnergyTransferMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    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_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ev_maximum_charge_power: f_0.ok_or(ExiError::MissingElement)?,
            ev_minimum_charge_power: f_1.ok_or(ExiError::MissingElement)?,
            ev_maximum_charge_current: f_2.ok_or(ExiError::MissingElement)?,
            ev_minimum_charge_current: f_3.ok_or(ExiError::MissingElement)?,
            ev_maximum_voltage: f_4.ok_or(ExiError::MissingElement)?,
            ev_minimum_voltage: f_5.ok_or(ExiError::MissingElement)?,
            target_soc: f_6,
            ev_maximum_discharge_power: f_7.ok_or(ExiError::MissingElement)?,
            ev_minimum_discharge_power: f_8.ok_or(ExiError::MissingElement)?,
            ev_maximum_discharge_current: f_9.ok_or(ExiError::MissingElement)?,
            ev_minimum_discharge_current: f_10.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `BPT_DC_CPDResEnergyTransferModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BPTDCCPDResEnergyTransferMode {
    /// `EVSEMaximumChargePower` element, 1..1.
    pub evse_maximum_charge_power: super::common::RationalNumber,
    /// `EVSEMinimumChargePower` element, 1..1.
    pub evse_minimum_charge_power: super::common::RationalNumber,
    /// `EVSEMaximumChargeCurrent` element, 1..1.
    pub evse_maximum_charge_current: super::common::RationalNumber,
    /// `EVSEMinimumChargeCurrent` element, 1..1.
    pub evse_minimum_charge_current: super::common::RationalNumber,
    /// `EVSEMaximumVoltage` element, 1..1.
    pub evse_maximum_voltage: super::common::RationalNumber,
    /// `EVSEMinimumVoltage` element, 1..1.
    pub evse_minimum_voltage: super::common::RationalNumber,
    /// `EVSEPowerRampLimitation` element, 0..1.
    pub evse_power_ramp_limitation: Option<super::common::RationalNumber>,
    /// `EVSEMaximumDischargePower` element, 1..1.
    pub evse_maximum_discharge_power: super::common::RationalNumber,
    /// `EVSEMinimumDischargePower` element, 1..1.
    pub evse_minimum_discharge_power: super::common::RationalNumber,
    /// `EVSEMaximumDischargeCurrent` element, 1..1.
    pub evse_maximum_discharge_current: super::common::RationalNumber,
    /// `EVSEMinimumDischargeCurrent` element, 1..1.
    pub evse_minimum_discharge_current: super::common::RationalNumber,
}

impl BPTDCCPDResEnergyTransferMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            evse_maximum_charge_power: super::common::RationalNumber::minimal(),
            evse_minimum_charge_power: super::common::RationalNumber::minimal(),
            evse_maximum_charge_current: super::common::RationalNumber::minimal(),
            evse_minimum_charge_current: super::common::RationalNumber::minimal(),
            evse_maximum_voltage: super::common::RationalNumber::minimal(),
            evse_minimum_voltage: super::common::RationalNumber::minimal(),
            evse_power_ramp_limitation: None,
            evse_maximum_discharge_power: super::common::RationalNumber::minimal(),
            evse_minimum_discharge_power: super::common::RationalNumber::minimal(),
            evse_maximum_discharge_current: super::common::RationalNumber::minimal(),
            evse_minimum_discharge_current: super::common::RationalNumber::minimal(),
        }
    }
}

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

impl BPTDCCPDResEnergyTransferMode {
    /// 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);
        // EVSEMaximumChargePower (1..1)
        {
            let item = &self.evse_maximum_charge_power;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVSEMinimumChargePower (1..1)
        {
            let item = &self.evse_minimum_charge_power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEMaximumChargeCurrent (1..1)
        {
            let item = &self.evse_maximum_charge_current;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVSEMinimumChargeCurrent (1..1)
        {
            let item = &self.evse_minimum_charge_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVSEMaximumVoltage (1..1)
        {
            let item = &self.evse_maximum_voltage;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEMinimumVoltage (1..1)
        {
            let item = &self.evse_minimum_voltage;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSEPowerRampLimitation (0..1)
        if let Some(item) = &self.evse_power_ramp_limitation {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVSEMaximumDischargePower (1..1)
        {
            let item = &self.evse_maximum_discharge_power;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVSEMinimumDischargePower (1..1)
        {
            let item = &self.evse_minimum_discharge_power;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVSEMaximumDischargeCurrent (1..1)
        {
            let item = &self.evse_maximum_discharge_current;
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // EVSEMinimumDischargeCurrent (1..1)
        {
            let item = &self.evse_minimum_discharge_current;
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BPTDCCPDResEnergyTransferMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            evse_maximum_charge_power: f_0.ok_or(ExiError::MissingElement)?,
            evse_minimum_charge_power: f_1.ok_or(ExiError::MissingElement)?,
            evse_maximum_charge_current: f_2.ok_or(ExiError::MissingElement)?,
            evse_minimum_charge_current: f_3.ok_or(ExiError::MissingElement)?,
            evse_maximum_voltage: f_4.ok_or(ExiError::MissingElement)?,
            evse_minimum_voltage: f_5.ok_or(ExiError::MissingElement)?,
            evse_power_ramp_limitation: f_6,
            evse_maximum_discharge_power: f_7.ok_or(ExiError::MissingElement)?,
            evse_minimum_discharge_power: f_8.ok_or(ExiError::MissingElement)?,
            evse_maximum_discharge_current: f_9.ok_or(ExiError::MissingElement)?,
            evse_minimum_discharge_current: f_10.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `BPT_Dynamic_DC_CLReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BPTDynamicDCCLReqControlMode {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `EVTargetEnergyRequest` element, 1..1.
    pub ev_target_energy_request: super::common::RationalNumber,
    /// `EVMaximumEnergyRequest` element, 1..1.
    pub ev_maximum_energy_request: super::common::RationalNumber,
    /// `EVMinimumEnergyRequest` element, 1..1.
    pub ev_minimum_energy_request: super::common::RationalNumber,
    /// `EVMaximumChargePower` element, 1..1.
    pub ev_maximum_charge_power: super::common::RationalNumber,
    /// `EVMinimumChargePower` element, 1..1.
    pub ev_minimum_charge_power: super::common::RationalNumber,
    /// `EVMaximumChargeCurrent` element, 1..1.
    pub ev_maximum_charge_current: super::common::RationalNumber,
    /// `EVMaximumVoltage` element, 1..1.
    pub ev_maximum_voltage: super::common::RationalNumber,
    /// `EVMinimumVoltage` element, 1..1.
    pub ev_minimum_voltage: super::common::RationalNumber,
    /// `EVMaximumDischargePower` element, 1..1.
    pub ev_maximum_discharge_power: super::common::RationalNumber,
    /// `EVMinimumDischargePower` element, 1..1.
    pub ev_minimum_discharge_power: super::common::RationalNumber,
    /// `EVMaximumDischargeCurrent` element, 1..1.
    pub ev_maximum_discharge_current: super::common::RationalNumber,
    /// `EVMaximumV2XEnergyRequest` element, 0..1.
    pub ev_maximum_v2_x_energy_request: Option<super::common::RationalNumber>,
    /// `EVMinimumV2XEnergyRequest` element, 0..1.
    pub ev_minimum_v2_x_energy_request: Option<super::common::RationalNumber>,
}

impl BPTDynamicDCCLReqControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            departure_time: None,
            ev_target_energy_request: super::common::RationalNumber::minimal(),
            ev_maximum_energy_request: super::common::RationalNumber::minimal(),
            ev_minimum_energy_request: super::common::RationalNumber::minimal(),
            ev_maximum_charge_power: super::common::RationalNumber::minimal(),
            ev_minimum_charge_power: super::common::RationalNumber::minimal(),
            ev_maximum_charge_current: super::common::RationalNumber::minimal(),
            ev_maximum_voltage: super::common::RationalNumber::minimal(),
            ev_minimum_voltage: super::common::RationalNumber::minimal(),
            ev_maximum_discharge_power: super::common::RationalNumber::minimal(),
            ev_minimum_discharge_power: super::common::RationalNumber::minimal(),
            ev_maximum_discharge_current: super::common::RationalNumber::minimal(),
            ev_maximum_v2_x_energy_request: None,
            ev_minimum_v2_x_energy_request: None,
        }
    }
}

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

impl BPTDynamicDCCLReqControlMode {
    /// 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);
        }
        // EVMaximumChargePower (1..1)
        {
            let item = &self.ev_maximum_charge_power;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMinimumChargePower (1..1)
        {
            let item = &self.ev_minimum_charge_power;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVMaximumChargeCurrent (1..1)
        {
            let item = &self.ev_maximum_charge_current;
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVMaximumVoltage (1..1)
        {
            let item = &self.ev_maximum_voltage;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVMinimumVoltage (1..1)
        {
            let item = &self.ev_minimum_voltage;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVMaximumDischargePower (1..1)
        {
            let item = &self.ev_maximum_discharge_power;
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // EVMinimumDischargePower (1..1)
        {
            let item = &self.ev_minimum_discharge_power;
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        // EVMaximumDischargeCurrent (1..1)
        {
            let item = &self.ev_maximum_discharge_current;
            w.start(e, 11, 0)?;
            item.encode_body(e)?;
            w.finish(11, 1);
        }
        // EVMaximumV2XEnergyRequest (0..1)
        if let Some(item) = &self.ev_maximum_v2_x_energy_request {
            w.start(e, 12, 0)?;
            item.encode_body(e)?;
            w.finish(12, 1);
        }
        // EVMinimumV2XEnergyRequest (0..1)
        if let Some(item) = &self.ev_minimum_v2_x_energy_request {
            w.start(e, 13, 0)?;
            item.encode_body(e)?;
            w.finish(13, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BPTDynamicDCCLReqControlMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        let mut f_11 = None;
        let mut f_12 = None;
        let mut f_13 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { index: 11, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_11 = Some(value);
                }
                Step::Item { index: 12, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_12 = Some(value);
                }
                Step::Item { index: 13, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_13 = 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)?,
            ev_maximum_charge_power: f_4.ok_or(ExiError::MissingElement)?,
            ev_minimum_charge_power: f_5.ok_or(ExiError::MissingElement)?,
            ev_maximum_charge_current: f_6.ok_or(ExiError::MissingElement)?,
            ev_maximum_voltage: f_7.ok_or(ExiError::MissingElement)?,
            ev_minimum_voltage: f_8.ok_or(ExiError::MissingElement)?,
            ev_maximum_discharge_power: f_9.ok_or(ExiError::MissingElement)?,
            ev_minimum_discharge_power: f_10.ok_or(ExiError::MissingElement)?,
            ev_maximum_discharge_current: f_11.ok_or(ExiError::MissingElement)?,
            ev_maximum_v2_x_energy_request: f_12,
            ev_minimum_v2_x_energy_request: f_13,
        })
    }
}

/// `BPT_Dynamic_DC_CLResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BPTDynamicDCCLResControlMode {
    /// `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>,
    /// `EVSEMaximumChargePower` element, 1..1.
    pub evse_maximum_charge_power: super::common::RationalNumber,
    /// `EVSEMinimumChargePower` element, 1..1.
    pub evse_minimum_charge_power: super::common::RationalNumber,
    /// `EVSEMaximumChargeCurrent` element, 1..1.
    pub evse_maximum_charge_current: super::common::RationalNumber,
    /// `EVSEMaximumVoltage` element, 1..1.
    pub evse_maximum_voltage: super::common::RationalNumber,
    /// `EVSEMaximumDischargePower` element, 1..1.
    pub evse_maximum_discharge_power: super::common::RationalNumber,
    /// `EVSEMinimumDischargePower` element, 1..1.
    pub evse_minimum_discharge_power: super::common::RationalNumber,
    /// `EVSEMaximumDischargeCurrent` element, 1..1.
    pub evse_maximum_discharge_current: super::common::RationalNumber,
    /// `EVSEMinimumVoltage` element, 1..1.
    pub evse_minimum_voltage: super::common::RationalNumber,
}

impl BPTDynamicDCCLResControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            departure_time: None,
            minimum_soc: None,
            target_soc: None,
            ack_max_delay: None,
            evse_maximum_charge_power: super::common::RationalNumber::minimal(),
            evse_minimum_charge_power: super::common::RationalNumber::minimal(),
            evse_maximum_charge_current: super::common::RationalNumber::minimal(),
            evse_maximum_voltage: super::common::RationalNumber::minimal(),
            evse_maximum_discharge_power: super::common::RationalNumber::minimal(),
            evse_minimum_discharge_power: super::common::RationalNumber::minimal(),
            evse_maximum_discharge_current: super::common::RationalNumber::minimal(),
            evse_minimum_voltage: super::common::RationalNumber::minimal(),
        }
    }
}

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

impl BPTDynamicDCCLResControlMode {
    /// 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);
        }
        // EVSEMaximumChargePower (1..1)
        {
            let item = &self.evse_maximum_charge_power;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEMinimumChargePower (1..1)
        {
            let item = &self.evse_minimum_charge_power;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSEMaximumChargeCurrent (1..1)
        {
            let item = &self.evse_maximum_charge_current;
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVSEMaximumVoltage (1..1)
        {
            let item = &self.evse_maximum_voltage;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVSEMaximumDischargePower (1..1)
        {
            let item = &self.evse_maximum_discharge_power;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVSEMinimumDischargePower (1..1)
        {
            let item = &self.evse_minimum_discharge_power;
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // EVSEMaximumDischargeCurrent (1..1)
        {
            let item = &self.evse_maximum_discharge_current;
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        // EVSEMinimumVoltage (1..1)
        {
            let item = &self.evse_minimum_voltage;
            w.start(e, 11, 0)?;
            item.encode_body(e)?;
            w.finish(11, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BPTDynamicDCCLResControlMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        let mut f_11 = None;
        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 { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { index: 11, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_11 = 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,
            evse_maximum_charge_power: f_4.ok_or(ExiError::MissingElement)?,
            evse_minimum_charge_power: f_5.ok_or(ExiError::MissingElement)?,
            evse_maximum_charge_current: f_6.ok_or(ExiError::MissingElement)?,
            evse_maximum_voltage: f_7.ok_or(ExiError::MissingElement)?,
            evse_maximum_discharge_power: f_8.ok_or(ExiError::MissingElement)?,
            evse_minimum_discharge_power: f_9.ok_or(ExiError::MissingElement)?,
            evse_maximum_discharge_current: f_10.ok_or(ExiError::MissingElement)?,
            evse_minimum_voltage: f_11.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `BPT_Scheduled_DC_CLReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BPTScheduledDCCLReqControlMode {
    /// `EVTargetEnergyRequest` element, 0..1.
    pub ev_target_energy_request: Option<super::common::RationalNumber>,
    /// `EVMaximumEnergyRequest` element, 0..1.
    pub ev_maximum_energy_request: Option<super::common::RationalNumber>,
    /// `EVMinimumEnergyRequest` element, 0..1.
    pub ev_minimum_energy_request: Option<super::common::RationalNumber>,
    /// `EVTargetCurrent` element, 1..1.
    pub ev_target_current: super::common::RationalNumber,
    /// `EVTargetVoltage` element, 1..1.
    pub ev_target_voltage: super::common::RationalNumber,
    /// `EVMaximumChargePower` element, 0..1.
    pub ev_maximum_charge_power: Option<super::common::RationalNumber>,
    /// `EVMinimumChargePower` element, 0..1.
    pub ev_minimum_charge_power: Option<super::common::RationalNumber>,
    /// `EVMaximumChargeCurrent` element, 0..1.
    pub ev_maximum_charge_current: Option<super::common::RationalNumber>,
    /// `EVMaximumVoltage` element, 0..1.
    pub ev_maximum_voltage: Option<super::common::RationalNumber>,
    /// `EVMinimumVoltage` element, 0..1.
    pub ev_minimum_voltage: Option<super::common::RationalNumber>,
    /// `EVMaximumDischargePower` element, 0..1.
    pub ev_maximum_discharge_power: Option<super::common::RationalNumber>,
    /// `EVMinimumDischargePower` element, 0..1.
    pub ev_minimum_discharge_power: Option<super::common::RationalNumber>,
    /// `EVMaximumDischargeCurrent` element, 0..1.
    pub ev_maximum_discharge_current: Option<super::common::RationalNumber>,
}

impl BPTScheduledDCCLReqControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            ev_target_energy_request: None,
            ev_maximum_energy_request: None,
            ev_minimum_energy_request: None,
            ev_target_current: super::common::RationalNumber::minimal(),
            ev_target_voltage: super::common::RationalNumber::minimal(),
            ev_maximum_charge_power: None,
            ev_minimum_charge_power: None,
            ev_maximum_charge_current: None,
            ev_maximum_voltage: None,
            ev_minimum_voltage: None,
            ev_maximum_discharge_power: None,
            ev_minimum_discharge_power: None,
            ev_maximum_discharge_current: None,
        }
    }
}

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

impl BPTScheduledDCCLReqControlMode {
    /// 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);
        }
        // EVTargetCurrent (1..1)
        {
            let item = &self.ev_target_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVTargetVoltage (1..1)
        {
            let item = &self.ev_target_voltage;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMaximumChargePower (0..1)
        if let Some(item) = &self.ev_maximum_charge_power {
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVMinimumChargePower (0..1)
        if let Some(item) = &self.ev_minimum_charge_power {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVMaximumChargeCurrent (0..1)
        if let Some(item) = &self.ev_maximum_charge_current {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVMaximumVoltage (0..1)
        if let Some(item) = &self.ev_maximum_voltage {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVMinimumVoltage (0..1)
        if let Some(item) = &self.ev_minimum_voltage {
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // EVMaximumDischargePower (0..1)
        if let Some(item) = &self.ev_maximum_discharge_power {
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        // EVMinimumDischargePower (0..1)
        if let Some(item) = &self.ev_minimum_discharge_power {
            w.start(e, 11, 0)?;
            item.encode_body(e)?;
            w.finish(11, 1);
        }
        // EVMaximumDischargeCurrent (0..1)
        if let Some(item) = &self.ev_maximum_discharge_current {
            w.start(e, 12, 0)?;
            item.encode_body(e)?;
            w.finish(12, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BPTScheduledDCCLReqControlMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        let mut f_11 = None;
        let mut f_12 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { index: 11, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_11 = Some(value);
                }
                Step::Item { index: 12, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_12 = 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,
            ev_target_current: f_3.ok_or(ExiError::MissingElement)?,
            ev_target_voltage: f_4.ok_or(ExiError::MissingElement)?,
            ev_maximum_charge_power: f_5,
            ev_minimum_charge_power: f_6,
            ev_maximum_charge_current: f_7,
            ev_maximum_voltage: f_8,
            ev_minimum_voltage: f_9,
            ev_maximum_discharge_power: f_10,
            ev_minimum_discharge_power: f_11,
            ev_maximum_discharge_current: f_12,
        })
    }
}

/// `BPT_Scheduled_DC_CLResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BPTScheduledDCCLResControlMode {
    /// `EVSEMaximumChargePower` element, 0..1.
    pub evse_maximum_charge_power: Option<super::common::RationalNumber>,
    /// `EVSEMinimumChargePower` element, 0..1.
    pub evse_minimum_charge_power: Option<super::common::RationalNumber>,
    /// `EVSEMaximumChargeCurrent` element, 0..1.
    pub evse_maximum_charge_current: Option<super::common::RationalNumber>,
    /// `EVSEMaximumVoltage` element, 0..1.
    pub evse_maximum_voltage: Option<super::common::RationalNumber>,
    /// `EVSEMaximumDischargePower` element, 0..1.
    pub evse_maximum_discharge_power: Option<super::common::RationalNumber>,
    /// `EVSEMinimumDischargePower` element, 0..1.
    pub evse_minimum_discharge_power: Option<super::common::RationalNumber>,
    /// `EVSEMaximumDischargeCurrent` element, 0..1.
    pub evse_maximum_discharge_current: Option<super::common::RationalNumber>,
    /// `EVSEMinimumVoltage` element, 0..1.
    pub evse_minimum_voltage: Option<super::common::RationalNumber>,
}

impl BPTScheduledDCCLResControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            evse_maximum_charge_power: None,
            evse_minimum_charge_power: None,
            evse_maximum_charge_current: None,
            evse_maximum_voltage: None,
            evse_maximum_discharge_power: None,
            evse_minimum_discharge_power: None,
            evse_maximum_discharge_current: None,
            evse_minimum_voltage: None,
        }
    }
}

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

impl BPTScheduledDCCLResControlMode {
    /// 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);
        // EVSEMaximumChargePower (0..1)
        if let Some(item) = &self.evse_maximum_charge_power {
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVSEMinimumChargePower (0..1)
        if let Some(item) = &self.evse_minimum_charge_power {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEMaximumChargeCurrent (0..1)
        if let Some(item) = &self.evse_maximum_charge_current {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVSEMaximumVoltage (0..1)
        if let Some(item) = &self.evse_maximum_voltage {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVSEMaximumDischargePower (0..1)
        if let Some(item) = &self.evse_maximum_discharge_power {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEMinimumDischargePower (0..1)
        if let Some(item) = &self.evse_minimum_discharge_power {
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSEMaximumDischargeCurrent (0..1)
        if let Some(item) = &self.evse_maximum_discharge_current {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVSEMinimumVoltage (0..1)
        if let Some(item) = &self.evse_minimum_voltage {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl BPTScheduledDCCLResControlMode {
    /// 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, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            evse_maximum_charge_power: f_0,
            evse_minimum_charge_power: f_1,
            evse_maximum_charge_current: f_2,
            evse_maximum_voltage: f_3,
            evse_maximum_discharge_power: f_4,
            evse_minimum_discharge_power: f_5,
            evse_maximum_discharge_current: f_6,
            evse_minimum_voltage: f_7,
        })
    }
}

/// `DC_CPDReqEnergyTransferModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCCPDReqEnergyTransferMode {
    /// `EVMaximumChargePower` element, 1..1.
    pub ev_maximum_charge_power: super::common::RationalNumber,
    /// `EVMinimumChargePower` element, 1..1.
    pub ev_minimum_charge_power: super::common::RationalNumber,
    /// `EVMaximumChargeCurrent` element, 1..1.
    pub ev_maximum_charge_current: super::common::RationalNumber,
    /// `EVMinimumChargeCurrent` element, 1..1.
    pub ev_minimum_charge_current: super::common::RationalNumber,
    /// `EVMaximumVoltage` element, 1..1.
    pub ev_maximum_voltage: super::common::RationalNumber,
    /// `EVMinimumVoltage` element, 1..1.
    pub ev_minimum_voltage: super::common::RationalNumber,
    /// `TargetSOC` element, 0..1.
    pub target_soc: Option<u8>,
}

impl DCCPDReqEnergyTransferMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            ev_maximum_charge_power: super::common::RationalNumber::minimal(),
            ev_minimum_charge_power: super::common::RationalNumber::minimal(),
            ev_maximum_charge_current: super::common::RationalNumber::minimal(),
            ev_minimum_charge_current: super::common::RationalNumber::minimal(),
            ev_maximum_voltage: super::common::RationalNumber::minimal(),
            ev_minimum_voltage: super::common::RationalNumber::minimal(),
            target_soc: None,
        }
    }
}

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

impl DCCPDReqEnergyTransferMode {
    /// 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);
        // EVMaximumChargePower (1..1)
        {
            let item = &self.ev_maximum_charge_power;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVMinimumChargePower (1..1)
        {
            let item = &self.ev_minimum_charge_power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVMaximumChargeCurrent (1..1)
        {
            let item = &self.ev_maximum_charge_current;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVMinimumChargeCurrent (1..1)
        {
            let item = &self.ev_minimum_charge_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVMaximumVoltage (1..1)
        {
            let item = &self.ev_maximum_voltage;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMinimumVoltage (1..1)
        {
            let item = &self.ev_minimum_voltage;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // TargetSOC (0..1)
        if let Some(item) = &self.target_soc {
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCCPDReqEnergyTransferMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    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_6 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ev_maximum_charge_power: f_0.ok_or(ExiError::MissingElement)?,
            ev_minimum_charge_power: f_1.ok_or(ExiError::MissingElement)?,
            ev_maximum_charge_current: f_2.ok_or(ExiError::MissingElement)?,
            ev_minimum_charge_current: f_3.ok_or(ExiError::MissingElement)?,
            ev_maximum_voltage: f_4.ok_or(ExiError::MissingElement)?,
            ev_minimum_voltage: f_5.ok_or(ExiError::MissingElement)?,
            target_soc: f_6,
        })
    }
}

/// `DC_CPDResEnergyTransferModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCCPDResEnergyTransferMode {
    /// `EVSEMaximumChargePower` element, 1..1.
    pub evse_maximum_charge_power: super::common::RationalNumber,
    /// `EVSEMinimumChargePower` element, 1..1.
    pub evse_minimum_charge_power: super::common::RationalNumber,
    /// `EVSEMaximumChargeCurrent` element, 1..1.
    pub evse_maximum_charge_current: super::common::RationalNumber,
    /// `EVSEMinimumChargeCurrent` element, 1..1.
    pub evse_minimum_charge_current: super::common::RationalNumber,
    /// `EVSEMaximumVoltage` element, 1..1.
    pub evse_maximum_voltage: super::common::RationalNumber,
    /// `EVSEMinimumVoltage` element, 1..1.
    pub evse_minimum_voltage: super::common::RationalNumber,
    /// `EVSEPowerRampLimitation` element, 0..1.
    pub evse_power_ramp_limitation: Option<super::common::RationalNumber>,
}

impl DCCPDResEnergyTransferMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            evse_maximum_charge_power: super::common::RationalNumber::minimal(),
            evse_minimum_charge_power: super::common::RationalNumber::minimal(),
            evse_maximum_charge_current: super::common::RationalNumber::minimal(),
            evse_minimum_charge_current: super::common::RationalNumber::minimal(),
            evse_maximum_voltage: super::common::RationalNumber::minimal(),
            evse_minimum_voltage: super::common::RationalNumber::minimal(),
            evse_power_ramp_limitation: None,
        }
    }
}

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

impl DCCPDResEnergyTransferMode {
    /// 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);
        // EVSEMaximumChargePower (1..1)
        {
            let item = &self.evse_maximum_charge_power;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVSEMinimumChargePower (1..1)
        {
            let item = &self.evse_minimum_charge_power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEMaximumChargeCurrent (1..1)
        {
            let item = &self.evse_maximum_charge_current;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVSEMinimumChargeCurrent (1..1)
        {
            let item = &self.evse_minimum_charge_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVSEMaximumVoltage (1..1)
        {
            let item = &self.evse_maximum_voltage;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEMinimumVoltage (1..1)
        {
            let item = &self.evse_minimum_voltage;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSEPowerRampLimitation (0..1)
        if let Some(item) = &self.evse_power_ramp_limitation {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

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

impl DCCableCheckReq {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self { header: super::common::MessageHeader::minimal() }
    }
}

impl DCCableCheckReq {
    /// 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 DCCableCheckReq {
    /// 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 DCCableCheckReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::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)? })
    }
}

/// `DC_CableCheckResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCCableCheckRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEProcessing` element, 1..1.
    pub evse_processing: super::common::Processing,
}

impl DCCableCheckRes {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            response_code: super::common::ResponseCode::ALL[0],
            evse_processing: super::common::Processing::ALL[0],
        }
    }
}

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

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

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

/// The `choice of 5` alternatives of [`DCChargeLoopReq`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DCChargeLoopReqChoice {
    /// `BPT_Dynamic_DC_CLReqControlMode`
    BPTDynamicDCCLReqControlMode(BPTDynamicDCCLReqControlMode),
    /// `BPT_Scheduled_DC_CLReqControlMode`
    BPTScheduledDCCLReqControlMode(BPTScheduledDCCLReqControlMode),
    /// `CLReqControlMode`
    CLReqControlMode(super::common::CLReqControlMode),
    /// `Dynamic_DC_CLReqControlMode`
    DynamicDCCLReqControlMode(DynamicDCCLReqControlMode),
    /// `Scheduled_DC_CLReqControlMode`
    ScheduledDCCLReqControlMode(ScheduledDCCLReqControlMode),
}

impl DCChargeLoopReqChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::BPTDynamicDCCLReqControlMode(_) => "BPT_Dynamic_DC_CLReqControlMode",
            Self::BPTScheduledDCCLReqControlMode(_) => "BPT_Scheduled_DC_CLReqControlMode",
            Self::CLReqControlMode(_) => "CLReqControlMode",
            Self::DynamicDCCLReqControlMode(_) => "Dynamic_DC_CLReqControlMode",
            Self::ScheduledDCCLReqControlMode(_) => "Scheduled_DC_CLReqControlMode",
        }
    }

    /// The smallest value of this choice the schema permits.
    ///
    /// The schema's first alternative, minimally built: a choice
    /// has no absent spelling, so a refusal has to pick one.
    #[must_use]
    pub fn minimal() -> Self {
        Self::BPTDynamicDCCLReqControlMode(BPTDynamicDCCLReqControlMode::minimal())
    }
}

/// `DC_ChargeLoopReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCChargeLoopReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `DisplayParameters` element, 0..1.
    pub display_parameters: Option<super::common::DisplayParameters>,
    /// `MeterInfoRequested` element, 1..1.
    pub meter_info_requested: bool,
    /// `EVPresentVoltage` element, 1..1.
    pub ev_present_voltage: super::common::RationalNumber,
    /// `choice of 5` element, 1..1.
    pub choice: DCChargeLoopReqChoice,
}

impl DCChargeLoopReq {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            display_parameters: None,
            meter_info_requested: false,
            ev_present_voltage: super::common::RationalNumber::minimal(),
            choice: DCChargeLoopReqChoice::minimal(),
        }
    }
}

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

impl DCChargeLoopReq {
    /// 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);
        }
        // EVPresentVoltage (1..1)
        {
            let item = &self.ev_present_voltage;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // choice of 5 (1..1)
        {
            let item = &self.choice;
            match item {
                DCChargeLoopReqChoice::BPTDynamicDCCLReqControlMode(value) => {
                    w.start_branch(e, 4, 0, 0)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopReqChoice::BPTScheduledDCCLReqControlMode(value) => {
                    w.start_branch(e, 4, 0, 1)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopReqChoice::CLReqControlMode(value) => {
                    w.start_branch(e, 4, 0, 2)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopReqChoice::DynamicDCCLReqControlMode(value) => {
                    w.start_branch(e, 4, 0, 3)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopReqChoice::ScheduledDCCLReqControlMode(value) => {
                    w.start_branch(e, 4, 0, 4)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCChargeLoopReq {
    /// 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 = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::DisplayParameters::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = BPTDynamicDCCLReqControlMode::decode_body(d)?;
                            DCChargeLoopReqChoice::BPTDynamicDCCLReqControlMode(value)
                        }
                        1 => {
                            let value = BPTScheduledDCCLReqControlMode::decode_body(d)?;
                            DCChargeLoopReqChoice::BPTScheduledDCCLReqControlMode(value)
                        }
                        2 => {
                            let value = super::common::CLReqControlMode::decode_body(d)?;
                            DCChargeLoopReqChoice::CLReqControlMode(value)
                        }
                        3 => {
                            let value = DynamicDCCLReqControlMode::decode_body(d)?;
                            DCChargeLoopReqChoice::DynamicDCCLReqControlMode(value)
                        }
                        4 => {
                            let value = ScheduledDCCLReqControlMode::decode_body(d)?;
                            DCChargeLoopReqChoice::ScheduledDCCLReqControlMode(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_4 = 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)?,
            ev_present_voltage: f_3.ok_or(ExiError::MissingElement)?,
            choice: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 5` alternatives of [`DCChargeLoopRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DCChargeLoopResChoice {
    /// `BPT_Dynamic_DC_CLResControlMode`
    BPTDynamicDCCLResControlMode(BPTDynamicDCCLResControlMode),
    /// `BPT_Scheduled_DC_CLResControlMode`
    BPTScheduledDCCLResControlMode(BPTScheduledDCCLResControlMode),
    /// `CLResControlMode`
    CLResControlMode(super::common::CLResControlMode),
    /// `Dynamic_DC_CLResControlMode`
    DynamicDCCLResControlMode(DynamicDCCLResControlMode),
    /// `Scheduled_DC_CLResControlMode`
    ScheduledDCCLResControlMode(ScheduledDCCLResControlMode),
}

impl DCChargeLoopResChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::BPTDynamicDCCLResControlMode(_) => "BPT_Dynamic_DC_CLResControlMode",
            Self::BPTScheduledDCCLResControlMode(_) => "BPT_Scheduled_DC_CLResControlMode",
            Self::CLResControlMode(_) => "CLResControlMode",
            Self::DynamicDCCLResControlMode(_) => "Dynamic_DC_CLResControlMode",
            Self::ScheduledDCCLResControlMode(_) => "Scheduled_DC_CLResControlMode",
        }
    }

    /// The smallest value of this choice the schema permits.
    ///
    /// The schema's first alternative, minimally built: a choice
    /// has no absent spelling, so a refusal has to pick one.
    #[must_use]
    pub fn minimal() -> Self {
        Self::BPTDynamicDCCLResControlMode(BPTDynamicDCCLResControlMode::minimal())
    }
}

/// `DC_ChargeLoopResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCChargeLoopRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEStatus` element, 0..1.
    pub evse_status: Option<super::common::EVSEStatus>,
    /// `MeterInfo` element, 0..1.
    pub meter_info: Option<super::common::MeterInfo>,
    /// `Receipt` element, 0..1.
    pub receipt: Option<super::common::Receipt>,
    /// `EVSEPresentCurrent` element, 1..1.
    pub evse_present_current: super::common::RationalNumber,
    /// `EVSEPresentVoltage` element, 1..1.
    pub evse_present_voltage: super::common::RationalNumber,
    /// `EVSEPowerLimitAchieved` element, 1..1.
    pub evse_power_limit_achieved: bool,
    /// `EVSECurrentLimitAchieved` element, 1..1.
    pub evse_current_limit_achieved: bool,
    /// `EVSEVoltageLimitAchieved` element, 1..1.
    pub evse_voltage_limit_achieved: bool,
    /// `choice of 5` element, 1..1.
    pub choice: DCChargeLoopResChoice,
}

impl DCChargeLoopRes {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            response_code: super::common::ResponseCode::ALL[0],
            evse_status: None,
            meter_info: None,
            receipt: None,
            evse_present_current: super::common::RationalNumber::minimal(),
            evse_present_voltage: super::common::RationalNumber::minimal(),
            evse_power_limit_achieved: false,
            evse_current_limit_achieved: false,
            evse_voltage_limit_achieved: false,
            choice: DCChargeLoopResChoice::minimal(),
        }
    }
}

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

impl DCChargeLoopRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ResponseCode (1..1)
        {
            let item = &self.response_code;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::ResponseCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVSEStatus (0..1)
        if let Some(item) = &self.evse_status {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // MeterInfo (0..1)
        if let Some(item) = &self.meter_info {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // Receipt (0..1)
        if let Some(item) = &self.receipt {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEPresentCurrent (1..1)
        {
            let item = &self.evse_present_current;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSEPresentVoltage (1..1)
        {
            let item = &self.evse_present_voltage;
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVSEPowerLimitAchieved (1..1)
        {
            let item = &self.evse_power_limit_achieved;
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 1);
        }
        // EVSECurrentLimitAchieved (1..1)
        {
            let item = &self.evse_current_limit_achieved;
            w.start(e, 8, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(8, 1);
        }
        // EVSEVoltageLimitAchieved (1..1)
        {
            let item = &self.evse_voltage_limit_achieved;
            w.start(e, 9, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(9, 1);
        }
        // choice of 5 (1..1)
        {
            let item = &self.choice;
            match item {
                DCChargeLoopResChoice::BPTDynamicDCCLResControlMode(value) => {
                    w.start_branch(e, 10, 0, 0)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopResChoice::BPTScheduledDCCLResControlMode(value) => {
                    w.start_branch(e, 10, 0, 1)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopResChoice::CLResControlMode(value) => {
                    w.start_branch(e, 10, 0, 2)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopResChoice::DynamicDCCLResControlMode(value) => {
                    w.start_branch(e, 10, 0, 3)?;
                    value.encode_body(e)?;
                }
                DCChargeLoopResChoice::ScheduledDCCLResControlMode(value) => {
                    w.start_branch(e, 10, 0, 4)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(10, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCChargeLoopRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        let mut f_10 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::EVSEStatus::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::MeterInfo::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::Receipt::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    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 { index: 10, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = BPTDynamicDCCLResControlMode::decode_body(d)?;
                            DCChargeLoopResChoice::BPTDynamicDCCLResControlMode(value)
                        }
                        1 => {
                            let value = BPTScheduledDCCLResControlMode::decode_body(d)?;
                            DCChargeLoopResChoice::BPTScheduledDCCLResControlMode(value)
                        }
                        2 => {
                            let value = super::common::CLResControlMode::decode_body(d)?;
                            DCChargeLoopResChoice::CLResControlMode(value)
                        }
                        3 => {
                            let value = DynamicDCCLResControlMode::decode_body(d)?;
                            DCChargeLoopResChoice::DynamicDCCLResControlMode(value)
                        }
                        4 => {
                            let value = ScheduledDCCLResControlMode::decode_body(d)?;
                            DCChargeLoopResChoice::ScheduledDCCLResControlMode(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_10 = 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,
            evse_present_current: f_5.ok_or(ExiError::MissingElement)?,
            evse_present_voltage: f_6.ok_or(ExiError::MissingElement)?,
            evse_power_limit_achieved: f_7.ok_or(ExiError::MissingElement)?,
            evse_current_limit_achieved: f_8.ok_or(ExiError::MissingElement)?,
            evse_voltage_limit_achieved: f_9.ok_or(ExiError::MissingElement)?,
            choice: f_10.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`DCChargeParameterDiscoveryReq`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DCChargeParameterDiscoveryReqChoice {
    /// `BPT_DC_CPDReqEnergyTransferMode`
    BPTDCCPDReqEnergyTransferMode(BPTDCCPDReqEnergyTransferMode),
    /// `DC_CPDReqEnergyTransferMode`
    DCCPDReqEnergyTransferMode(DCCPDReqEnergyTransferMode),
}

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

    /// The smallest value of this choice the schema permits.
    ///
    /// The schema's first alternative, minimally built: a choice
    /// has no absent spelling, so a refusal has to pick one.
    #[must_use]
    pub fn minimal() -> Self {
        Self::BPTDCCPDReqEnergyTransferMode(BPTDCCPDReqEnergyTransferMode::minimal())
    }
}

/// `DC_ChargeParameterDiscoveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCChargeParameterDiscoveryReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `choice of 2` element, 1..1.
    pub choice: DCChargeParameterDiscoveryReqChoice,
}

impl DCChargeParameterDiscoveryReq {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            choice: DCChargeParameterDiscoveryReqChoice::minimal(),
        }
    }
}

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

impl DCChargeParameterDiscoveryReq {
    /// 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);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                DCChargeParameterDiscoveryReqChoice::BPTDCCPDReqEnergyTransferMode(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    value.encode_body(e)?;
                }
                DCChargeParameterDiscoveryReqChoice::DCCPDReqEnergyTransferMode(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DCChargeParameterDiscoveryReq {
    /// 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 = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = BPTDCCPDReqEnergyTransferMode::decode_body(d)?;
                            DCChargeParameterDiscoveryReqChoice::BPTDCCPDReqEnergyTransferMode(
                                value,
                            )
                        }
                        1 => {
                            let value = DCCPDReqEnergyTransferMode::decode_body(d)?;
                            DCChargeParameterDiscoveryReqChoice::DCCPDReqEnergyTransferMode(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            choice: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`DCChargeParameterDiscoveryRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DCChargeParameterDiscoveryResChoice {
    /// `BPT_DC_CPDResEnergyTransferMode`
    BPTDCCPDResEnergyTransferMode(BPTDCCPDResEnergyTransferMode),
    /// `DC_CPDResEnergyTransferMode`
    DCCPDResEnergyTransferMode(DCCPDResEnergyTransferMode),
}

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

    /// The smallest value of this choice the schema permits.
    ///
    /// The schema's first alternative, minimally built: a choice
    /// has no absent spelling, so a refusal has to pick one.
    #[must_use]
    pub fn minimal() -> Self {
        Self::BPTDCCPDResEnergyTransferMode(BPTDCCPDResEnergyTransferMode::minimal())
    }
}

/// `DC_ChargeParameterDiscoveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCChargeParameterDiscoveryRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `choice of 2` element, 1..1.
    pub choice: DCChargeParameterDiscoveryResChoice,
}

impl DCChargeParameterDiscoveryRes {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            response_code: super::common::ResponseCode::ALL[0],
            choice: DCChargeParameterDiscoveryResChoice::minimal(),
        }
    }
}

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

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

impl DCChargeParameterDiscoveryRes {
    /// 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 = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = BPTDCCPDResEnergyTransferMode::decode_body(d)?;
                            DCChargeParameterDiscoveryResChoice::BPTDCCPDResEnergyTransferMode(
                                value,
                            )
                        }
                        1 => {
                            let value = DCCPDResEnergyTransferMode::decode_body(d)?;
                            DCChargeParameterDiscoveryResChoice::DCCPDResEnergyTransferMode(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_2 = 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)?,
            choice: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DC_PreChargeReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCPreChargeReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
    /// `EVPresentVoltage` element, 1..1.
    pub ev_present_voltage: super::common::RationalNumber,
    /// `EVTargetVoltage` element, 1..1.
    pub ev_target_voltage: super::common::RationalNumber,
}

impl DCPreChargeReq {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            ev_processing: super::common::Processing::ALL[0],
            ev_present_voltage: super::common::RationalNumber::minimal(),
            ev_target_voltage: super::common::RationalNumber::minimal(),
        }
    }
}

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

impl DCPreChargeReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVProcessing (1..1)
        {
            let item = &self.ev_processing;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), super::common::Processing::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVPresentVoltage (1..1)
        {
            let item = &self.ev_present_voltage;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVTargetVoltage (1..1)
        {
            let item = &self.ev_target_voltage;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `DC_PreChargeResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCPreChargeRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEPresentVoltage` element, 1..1.
    pub evse_present_voltage: super::common::RationalNumber,
}

impl DCPreChargeRes {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            response_code: super::common::ResponseCode::ALL[0],
            evse_present_voltage: super::common::RationalNumber::minimal(),
        }
    }
}

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

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

impl DCPreChargeRes {
    /// 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 = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = 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_present_voltage: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DC_WeldingDetectionReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCWeldingDetectionReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
}

impl DCWeldingDetectionReq {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            ev_processing: super::common::Processing::ALL[0],
        }
    }
}

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

impl DCWeldingDetectionReq {
    /// 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 = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_processing: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `DC_WeldingDetectionResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DCWeldingDetectionRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEPresentVoltage` element, 1..1.
    pub evse_present_voltage: super::common::RationalNumber,
}

impl DCWeldingDetectionRes {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            header: super::common::MessageHeader::minimal(),
            response_code: super::common::ResponseCode::ALL[0],
            evse_present_voltage: super::common::RationalNumber::minimal(),
        }
    }
}

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

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

impl DCWeldingDetectionRes {
    /// 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 = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = 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_present_voltage: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `Dynamic_DC_CLReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DynamicDCCLReqControlMode {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `EVTargetEnergyRequest` element, 1..1.
    pub ev_target_energy_request: super::common::RationalNumber,
    /// `EVMaximumEnergyRequest` element, 1..1.
    pub ev_maximum_energy_request: super::common::RationalNumber,
    /// `EVMinimumEnergyRequest` element, 1..1.
    pub ev_minimum_energy_request: super::common::RationalNumber,
    /// `EVMaximumChargePower` element, 1..1.
    pub ev_maximum_charge_power: super::common::RationalNumber,
    /// `EVMinimumChargePower` element, 1..1.
    pub ev_minimum_charge_power: super::common::RationalNumber,
    /// `EVMaximumChargeCurrent` element, 1..1.
    pub ev_maximum_charge_current: super::common::RationalNumber,
    /// `EVMaximumVoltage` element, 1..1.
    pub ev_maximum_voltage: super::common::RationalNumber,
    /// `EVMinimumVoltage` element, 1..1.
    pub ev_minimum_voltage: super::common::RationalNumber,
}

impl DynamicDCCLReqControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            departure_time: None,
            ev_target_energy_request: super::common::RationalNumber::minimal(),
            ev_maximum_energy_request: super::common::RationalNumber::minimal(),
            ev_minimum_energy_request: super::common::RationalNumber::minimal(),
            ev_maximum_charge_power: super::common::RationalNumber::minimal(),
            ev_minimum_charge_power: super::common::RationalNumber::minimal(),
            ev_maximum_charge_current: super::common::RationalNumber::minimal(),
            ev_maximum_voltage: super::common::RationalNumber::minimal(),
            ev_minimum_voltage: super::common::RationalNumber::minimal(),
        }
    }
}

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

impl DynamicDCCLReqControlMode {
    /// 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);
        }
        // EVMaximumChargePower (1..1)
        {
            let item = &self.ev_maximum_charge_power;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMinimumChargePower (1..1)
        {
            let item = &self.ev_minimum_charge_power;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVMaximumChargeCurrent (1..1)
        {
            let item = &self.ev_maximum_charge_current;
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVMaximumVoltage (1..1)
        {
            let item = &self.ev_maximum_voltage;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVMinimumVoltage (1..1)
        {
            let item = &self.ev_minimum_voltage;
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DynamicDCCLReqControlMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { .. } => 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)?,
            ev_maximum_charge_power: f_4.ok_or(ExiError::MissingElement)?,
            ev_minimum_charge_power: f_5.ok_or(ExiError::MissingElement)?,
            ev_maximum_charge_current: f_6.ok_or(ExiError::MissingElement)?,
            ev_maximum_voltage: f_7.ok_or(ExiError::MissingElement)?,
            ev_minimum_voltage: f_8.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `Dynamic_DC_CLResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DynamicDCCLResControlMode {
    /// `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>,
    /// `EVSEMaximumChargePower` element, 1..1.
    pub evse_maximum_charge_power: super::common::RationalNumber,
    /// `EVSEMinimumChargePower` element, 1..1.
    pub evse_minimum_charge_power: super::common::RationalNumber,
    /// `EVSEMaximumChargeCurrent` element, 1..1.
    pub evse_maximum_charge_current: super::common::RationalNumber,
    /// `EVSEMaximumVoltage` element, 1..1.
    pub evse_maximum_voltage: super::common::RationalNumber,
}

impl DynamicDCCLResControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            departure_time: None,
            minimum_soc: None,
            target_soc: None,
            ack_max_delay: None,
            evse_maximum_charge_power: super::common::RationalNumber::minimal(),
            evse_minimum_charge_power: super::common::RationalNumber::minimal(),
            evse_maximum_charge_current: super::common::RationalNumber::minimal(),
            evse_maximum_voltage: super::common::RationalNumber::minimal(),
        }
    }
}

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

impl DynamicDCCLResControlMode {
    /// 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);
        }
        // EVSEMaximumChargePower (1..1)
        {
            let item = &self.evse_maximum_charge_power;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVSEMinimumChargePower (1..1)
        {
            let item = &self.evse_minimum_charge_power;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVSEMaximumChargeCurrent (1..1)
        {
            let item = &self.evse_maximum_charge_current;
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVSEMaximumVoltage (1..1)
        {
            let item = &self.evse_maximum_voltage;
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DynamicDCCLResControlMode {
    /// 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 = 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 { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { .. } => 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,
            evse_maximum_charge_power: f_4.ok_or(ExiError::MissingElement)?,
            evse_minimum_charge_power: f_5.ok_or(ExiError::MissingElement)?,
            evse_maximum_charge_current: f_6.ok_or(ExiError::MissingElement)?,
            evse_maximum_voltage: f_7.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `Scheduled_DC_CLReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledDCCLReqControlMode {
    /// `EVTargetEnergyRequest` element, 0..1.
    pub ev_target_energy_request: Option<super::common::RationalNumber>,
    /// `EVMaximumEnergyRequest` element, 0..1.
    pub ev_maximum_energy_request: Option<super::common::RationalNumber>,
    /// `EVMinimumEnergyRequest` element, 0..1.
    pub ev_minimum_energy_request: Option<super::common::RationalNumber>,
    /// `EVTargetCurrent` element, 1..1.
    pub ev_target_current: super::common::RationalNumber,
    /// `EVTargetVoltage` element, 1..1.
    pub ev_target_voltage: super::common::RationalNumber,
    /// `EVMaximumChargePower` element, 0..1.
    pub ev_maximum_charge_power: Option<super::common::RationalNumber>,
    /// `EVMinimumChargePower` element, 0..1.
    pub ev_minimum_charge_power: Option<super::common::RationalNumber>,
    /// `EVMaximumChargeCurrent` element, 0..1.
    pub ev_maximum_charge_current: Option<super::common::RationalNumber>,
    /// `EVMaximumVoltage` element, 0..1.
    pub ev_maximum_voltage: Option<super::common::RationalNumber>,
    /// `EVMinimumVoltage` element, 0..1.
    pub ev_minimum_voltage: Option<super::common::RationalNumber>,
}

impl ScheduledDCCLReqControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            ev_target_energy_request: None,
            ev_maximum_energy_request: None,
            ev_minimum_energy_request: None,
            ev_target_current: super::common::RationalNumber::minimal(),
            ev_target_voltage: super::common::RationalNumber::minimal(),
            ev_maximum_charge_power: None,
            ev_minimum_charge_power: None,
            ev_maximum_charge_current: None,
            ev_maximum_voltage: None,
            ev_minimum_voltage: None,
        }
    }
}

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

impl ScheduledDCCLReqControlMode {
    /// 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);
        }
        // EVTargetCurrent (1..1)
        {
            let item = &self.ev_target_current;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVTargetVoltage (1..1)
        {
            let item = &self.ev_target_voltage;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMaximumChargePower (0..1)
        if let Some(item) = &self.ev_maximum_charge_power {
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVMinimumChargePower (0..1)
        if let Some(item) = &self.ev_minimum_charge_power {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVMaximumChargeCurrent (0..1)
        if let Some(item) = &self.ev_maximum_charge_current {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // EVMaximumVoltage (0..1)
        if let Some(item) = &self.ev_maximum_voltage {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // EVMinimumVoltage (0..1)
        if let Some(item) = &self.ev_minimum_voltage {
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ScheduledDCCLReqControlMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        let mut f_9 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_7 = Some(value);
                }
                Step::Item { index: 8, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_8 = Some(value);
                }
                Step::Item { index: 9, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_9 = 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,
            ev_target_current: f_3.ok_or(ExiError::MissingElement)?,
            ev_target_voltage: f_4.ok_or(ExiError::MissingElement)?,
            ev_maximum_charge_power: f_5,
            ev_minimum_charge_power: f_6,
            ev_maximum_charge_current: f_7,
            ev_maximum_voltage: f_8,
            ev_minimum_voltage: f_9,
        })
    }
}

/// `Scheduled_DC_CLResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledDCCLResControlMode {
    /// `EVSEMaximumChargePower` element, 0..1.
    pub evse_maximum_charge_power: Option<super::common::RationalNumber>,
    /// `EVSEMinimumChargePower` element, 0..1.
    pub evse_minimum_charge_power: Option<super::common::RationalNumber>,
    /// `EVSEMaximumChargeCurrent` element, 0..1.
    pub evse_maximum_charge_current: Option<super::common::RationalNumber>,
    /// `EVSEMaximumVoltage` element, 0..1.
    pub evse_maximum_voltage: Option<super::common::RationalNumber>,
}

impl ScheduledDCCLResControlMode {
    /// The smallest value of this type the schema permits.
    ///
    /// Every required field at its own minimum, every optional one
    /// absent. Built to be encodable rather than meaningful: it is
    /// what a refusal is made of when there is nothing to report.
    #[must_use]
    pub fn minimal() -> Self {
        Self {
            evse_maximum_charge_power: None,
            evse_minimum_charge_power: None,
            evse_maximum_charge_current: None,
            evse_maximum_voltage: None,
        }
    }
}

impl ScheduledDCCLResControlMode {
    /// 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 ScheduledDCCLResControlMode {
    /// 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);
        // EVSEMaximumChargePower (0..1)
        if let Some(item) = &self.evse_maximum_charge_power {
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // EVSEMinimumChargePower (0..1)
        if let Some(item) = &self.evse_minimum_charge_power {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // EVSEMaximumChargeCurrent (0..1)
        if let Some(item) = &self.evse_maximum_charge_current {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // EVSEMaximumVoltage (0..1)
        if let Some(item) = &self.evse_maximum_voltage {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

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

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

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

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

impl crate::exi::ExiDocument for BPTDCCPDReqEnergyTransferMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 BPTDCCPDResEnergyTransferMode {
    /// Document event code of `BPT_DC_CPDResEnergyTransferMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 1;
}

impl crate::exi::ExiDocument for BPTDCCPDResEnergyTransferMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 BPTDynamicDCCLReqControlMode {
    /// Document event code of `BPT_Dynamic_DC_CLReqControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 2;
}

impl crate::exi::ExiDocument for BPTDynamicDCCLReqControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 BPTDynamicDCCLResControlMode {
    /// Document event code of `BPT_Dynamic_DC_CLResControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 3;
}

impl crate::exi::ExiDocument for BPTDynamicDCCLResControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 BPTScheduledDCCLReqControlMode {
    /// Document event code of `BPT_Scheduled_DC_CLReqControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 4;
}

impl crate::exi::ExiDocument for BPTScheduledDCCLReqControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 BPTScheduledDCCLResControlMode {
    /// Document event code of `BPT_Scheduled_DC_CLResControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 5;
}

impl crate::exi::ExiDocument for BPTScheduledDCCLResControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCCPDReqEnergyTransferMode {
    /// Document event code of `DC_CPDReqEnergyTransferMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 9;
}

impl crate::exi::ExiDocument for DCCPDReqEnergyTransferMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCCPDResEnergyTransferMode {
    /// Document event code of `DC_CPDResEnergyTransferMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 10;
}

impl crate::exi::ExiDocument for DCCPDResEnergyTransferMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCCableCheckReq {
    /// Document event code of `DC_CableCheckReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 11;
}

impl crate::exi::ExiDocument for DCCableCheckReq {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCCableCheckRes {
    /// Document event code of `DC_CableCheckRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 12;
}

impl crate::exi::ExiDocument for DCCableCheckRes {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCChargeLoopReq {
    /// Document event code of `DC_ChargeLoopReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 13;
}

impl crate::exi::ExiDocument for DCChargeLoopReq {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCChargeLoopRes {
    /// Document event code of `DC_ChargeLoopRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 14;
}

impl crate::exi::ExiDocument for DCChargeLoopRes {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCChargeParameterDiscoveryReq {
    /// Document event code of `DC_ChargeParameterDiscoveryReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 15;
}

impl crate::exi::ExiDocument for DCChargeParameterDiscoveryReq {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCChargeParameterDiscoveryRes {
    /// Document event code of `DC_ChargeParameterDiscoveryRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 16;
}

impl crate::exi::ExiDocument for DCChargeParameterDiscoveryRes {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCPreChargeReq {
    /// Document event code of `DC_PreChargeReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 17;
}

impl crate::exi::ExiDocument for DCPreChargeReq {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCPreChargeRes {
    /// Document event code of `DC_PreChargeRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 18;
}

impl crate::exi::ExiDocument for DCPreChargeRes {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCWeldingDetectionReq {
    /// Document event code of `DC_WeldingDetectionReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 19;
}

impl crate::exi::ExiDocument for DCWeldingDetectionReq {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DCWeldingDetectionRes {
    /// Document event code of `DC_WeldingDetectionRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 20;
}

impl crate::exi::ExiDocument for DCWeldingDetectionRes {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DynamicDCCLReqControlMode {
    /// Document event code of `Dynamic_DC_CLReqControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 24;
}

impl crate::exi::ExiDocument for DynamicDCCLReqControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 DynamicDCCLResControlMode {
    /// Document event code of `Dynamic_DC_CLResControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 25;
}

impl crate::exi::ExiDocument for DynamicDCCLResControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 ScheduledDCCLReqControlMode {
    /// Document event code of `Scheduled_DC_CLReqControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 37;
}

impl crate::exi::ExiDocument for ScheduledDCCLReqControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 ScheduledDCCLResControlMode {
    /// Document event code of `Scheduled_DC_CLResControlMode` in this schema set.
    pub const DOCUMENT_CODE: u64 = 38;
}

impl crate::exi::ExiDocument for ScheduledDCCLResControlMode {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 {
    /// `BPT_DC_CPDReqEnergyTransferMode`
    BPTDCCPDReqEnergyTransferMode(BPTDCCPDReqEnergyTransferMode),
    /// `BPT_DC_CPDResEnergyTransferMode`
    BPTDCCPDResEnergyTransferMode(BPTDCCPDResEnergyTransferMode),
    /// `BPT_Dynamic_DC_CLReqControlMode`
    BPTDynamicDCCLReqControlMode(BPTDynamicDCCLReqControlMode),
    /// `BPT_Dynamic_DC_CLResControlMode`
    BPTDynamicDCCLResControlMode(BPTDynamicDCCLResControlMode),
    /// `BPT_Scheduled_DC_CLReqControlMode`
    BPTScheduledDCCLReqControlMode(BPTScheduledDCCLReqControlMode),
    /// `BPT_Scheduled_DC_CLResControlMode`
    BPTScheduledDCCLResControlMode(BPTScheduledDCCLResControlMode),
    /// `DC_CPDReqEnergyTransferMode`
    DCCPDReqEnergyTransferMode(DCCPDReqEnergyTransferMode),
    /// `DC_CPDResEnergyTransferMode`
    DCCPDResEnergyTransferMode(DCCPDResEnergyTransferMode),
    /// `DC_CableCheckReq`
    DCCableCheckReq(DCCableCheckReq),
    /// `DC_CableCheckRes`
    DCCableCheckRes(DCCableCheckRes),
    /// `DC_ChargeLoopReq`
    DCChargeLoopReq(DCChargeLoopReq),
    /// `DC_ChargeLoopRes`
    DCChargeLoopRes(DCChargeLoopRes),
    /// `DC_ChargeParameterDiscoveryReq`
    DCChargeParameterDiscoveryReq(DCChargeParameterDiscoveryReq),
    /// `DC_ChargeParameterDiscoveryRes`
    DCChargeParameterDiscoveryRes(DCChargeParameterDiscoveryRes),
    /// `DC_PreChargeReq`
    DCPreChargeReq(DCPreChargeReq),
    /// `DC_PreChargeRes`
    DCPreChargeRes(DCPreChargeRes),
    /// `DC_WeldingDetectionReq`
    DCWeldingDetectionReq(DCWeldingDetectionReq),
    /// `DC_WeldingDetectionRes`
    DCWeldingDetectionRes(DCWeldingDetectionRes),
    /// `Dynamic_DC_CLReqControlMode`
    DynamicDCCLReqControlMode(DynamicDCCLReqControlMode),
    /// `Dynamic_DC_CLResControlMode`
    DynamicDCCLResControlMode(DynamicDCCLResControlMode),
    /// `Scheduled_DC_CLReqControlMode`
    ScheduledDCCLReqControlMode(ScheduledDCCLReqControlMode),
    /// `Scheduled_DC_CLResControlMode`
    ScheduledDCCLResControlMode(ScheduledDCCLResControlMode),
}

impl Document {
    /// The element name of this document.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::BPTDCCPDReqEnergyTransferMode(_) => "BPT_DC_CPDReqEnergyTransferMode",
            Self::BPTDCCPDResEnergyTransferMode(_) => "BPT_DC_CPDResEnergyTransferMode",
            Self::BPTDynamicDCCLReqControlMode(_) => "BPT_Dynamic_DC_CLReqControlMode",
            Self::BPTDynamicDCCLResControlMode(_) => "BPT_Dynamic_DC_CLResControlMode",
            Self::BPTScheduledDCCLReqControlMode(_) => "BPT_Scheduled_DC_CLReqControlMode",
            Self::BPTScheduledDCCLResControlMode(_) => "BPT_Scheduled_DC_CLResControlMode",
            Self::DCCPDReqEnergyTransferMode(_) => "DC_CPDReqEnergyTransferMode",
            Self::DCCPDResEnergyTransferMode(_) => "DC_CPDResEnergyTransferMode",
            Self::DCCableCheckReq(_) => "DC_CableCheckReq",
            Self::DCCableCheckRes(_) => "DC_CableCheckRes",
            Self::DCChargeLoopReq(_) => "DC_ChargeLoopReq",
            Self::DCChargeLoopRes(_) => "DC_ChargeLoopRes",
            Self::DCChargeParameterDiscoveryReq(_) => "DC_ChargeParameterDiscoveryReq",
            Self::DCChargeParameterDiscoveryRes(_) => "DC_ChargeParameterDiscoveryRes",
            Self::DCPreChargeReq(_) => "DC_PreChargeReq",
            Self::DCPreChargeRes(_) => "DC_PreChargeRes",
            Self::DCWeldingDetectionReq(_) => "DC_WeldingDetectionReq",
            Self::DCWeldingDetectionRes(_) => "DC_WeldingDetectionRes",
            Self::DynamicDCCLReqControlMode(_) => "Dynamic_DC_CLReqControlMode",
            Self::DynamicDCCLResControlMode(_) => "Dynamic_DC_CLResControlMode",
            Self::ScheduledDCCLReqControlMode(_) => "Scheduled_DC_CLReqControlMode",
            Self::ScheduledDCCLResControlMode(_) => "Scheduled_DC_CLResControlMode",
        }
    }

    /// The document event code of this message.
    #[must_use]
    pub const fn code(&self) -> u64 {
        match self {
            Self::BPTDCCPDReqEnergyTransferMode(_) => 0,
            Self::BPTDCCPDResEnergyTransferMode(_) => 1,
            Self::BPTDynamicDCCLReqControlMode(_) => 2,
            Self::BPTDynamicDCCLResControlMode(_) => 3,
            Self::BPTScheduledDCCLReqControlMode(_) => 4,
            Self::BPTScheduledDCCLResControlMode(_) => 5,
            Self::DCCPDReqEnergyTransferMode(_) => 9,
            Self::DCCPDResEnergyTransferMode(_) => 10,
            Self::DCCableCheckReq(_) => 11,
            Self::DCCableCheckRes(_) => 12,
            Self::DCChargeLoopReq(_) => 13,
            Self::DCChargeLoopRes(_) => 14,
            Self::DCChargeParameterDiscoveryReq(_) => 15,
            Self::DCChargeParameterDiscoveryRes(_) => 16,
            Self::DCPreChargeReq(_) => 17,
            Self::DCPreChargeRes(_) => 18,
            Self::DCWeldingDetectionReq(_) => 19,
            Self::DCWeldingDetectionRes(_) => 20,
            Self::DynamicDCCLReqControlMode(_) => 24,
            Self::DynamicDCCLResControlMode(_) => 25,
            Self::ScheduledDCCLReqControlMode(_) => 37,
            Self::ScheduledDCCLResControlMode(_) => 38,
        }
    }
}

impl crate::exi::ExiDocument for Document {
    fn to_slice_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(self.code(), DOCUMENT_WIDTH)?;
        match self {
            Self::BPTDCCPDReqEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::BPTDCCPDResEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::BPTDynamicDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::BPTDynamicDCCLResControlMode(m) => m.encode_body(&mut e)?,
            Self::BPTScheduledDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::BPTScheduledDCCLResControlMode(m) => m.encode_body(&mut e)?,
            Self::DCCPDReqEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::DCCPDResEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::DCCableCheckReq(m) => m.encode_body(&mut e)?,
            Self::DCCableCheckRes(m) => m.encode_body(&mut e)?,
            Self::DCChargeLoopReq(m) => m.encode_body(&mut e)?,
            Self::DCChargeLoopRes(m) => m.encode_body(&mut e)?,
            Self::DCChargeParameterDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::DCChargeParameterDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::DCPreChargeReq(m) => m.encode_body(&mut e)?,
            Self::DCPreChargeRes(m) => m.encode_body(&mut e)?,
            Self::DCWeldingDetectionReq(m) => m.encode_body(&mut e)?,
            Self::DCWeldingDetectionRes(m) => m.encode_body(&mut e)?,
            Self::DynamicDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::DynamicDCCLResControlMode(m) => m.encode_body(&mut e)?,
            Self::ScheduledDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::ScheduledDCCLResControlMode(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::BPTDCCPDReqEnergyTransferMode(BPTDCCPDReqEnergyTransferMode::decode_body(
                &mut d,
            )?),
            1 => Self::BPTDCCPDResEnergyTransferMode(BPTDCCPDResEnergyTransferMode::decode_body(
                &mut d,
            )?),
            2 => Self::BPTDynamicDCCLReqControlMode(BPTDynamicDCCLReqControlMode::decode_body(
                &mut d,
            )?),
            3 => Self::BPTDynamicDCCLResControlMode(BPTDynamicDCCLResControlMode::decode_body(
                &mut d,
            )?),
            4 => Self::BPTScheduledDCCLReqControlMode(BPTScheduledDCCLReqControlMode::decode_body(
                &mut d,
            )?),
            5 => Self::BPTScheduledDCCLResControlMode(BPTScheduledDCCLResControlMode::decode_body(
                &mut d,
            )?),
            9 => Self::DCCPDReqEnergyTransferMode(DCCPDReqEnergyTransferMode::decode_body(&mut d)?),
            10 => {
                Self::DCCPDResEnergyTransferMode(DCCPDResEnergyTransferMode::decode_body(&mut d)?)
            }
            11 => Self::DCCableCheckReq(DCCableCheckReq::decode_body(&mut d)?),
            12 => Self::DCCableCheckRes(DCCableCheckRes::decode_body(&mut d)?),
            13 => Self::DCChargeLoopReq(DCChargeLoopReq::decode_body(&mut d)?),
            14 => Self::DCChargeLoopRes(DCChargeLoopRes::decode_body(&mut d)?),
            15 => Self::DCChargeParameterDiscoveryReq(DCChargeParameterDiscoveryReq::decode_body(
                &mut d,
            )?),
            16 => Self::DCChargeParameterDiscoveryRes(DCChargeParameterDiscoveryRes::decode_body(
                &mut d,
            )?),
            17 => Self::DCPreChargeReq(DCPreChargeReq::decode_body(&mut d)?),
            18 => Self::DCPreChargeRes(DCPreChargeRes::decode_body(&mut d)?),
            19 => Self::DCWeldingDetectionReq(DCWeldingDetectionReq::decode_body(&mut d)?),
            20 => Self::DCWeldingDetectionRes(DCWeldingDetectionRes::decode_body(&mut d)?),
            24 => Self::DynamicDCCLReqControlMode(DynamicDCCLReqControlMode::decode_body(&mut d)?),
            25 => Self::DynamicDCCLResControlMode(DynamicDCCLResControlMode::decode_body(&mut d)?),
            37 => {
                Self::ScheduledDCCLReqControlMode(ScheduledDCCLReqControlMode::decode_body(&mut d)?)
            }
            38 => {
                Self::ScheduledDCCLResControlMode(ScheduledDCCLResControlMode::decode_body(&mut d)?)
            }
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.finish()?;
        Ok(value)
    }
}

impl Document {
    /// The message header, for the messages that have one.
    ///
    /// `None` only for the few schema elements that are not
    /// messages in their own right.
    #[must_use]
    pub const fn header(&self) -> Option<&super::common::MessageHeader> {
        match self {
            Self::DCCableCheckReq(m) => Some(&m.header),
            Self::DCCableCheckRes(m) => Some(&m.header),
            Self::DCChargeLoopReq(m) => Some(&m.header),
            Self::DCChargeLoopRes(m) => Some(&m.header),
            Self::DCChargeParameterDiscoveryReq(m) => Some(&m.header),
            Self::DCChargeParameterDiscoveryRes(m) => Some(&m.header),
            Self::DCPreChargeReq(m) => Some(&m.header),
            Self::DCPreChargeRes(m) => Some(&m.header),
            Self::DCWeldingDetectionReq(m) => Some(&m.header),
            Self::DCWeldingDetectionRes(m) => Some(&m.header),
            _ => None,
        }
    }

    /// The message header, mutably.
    ///
    /// The counterpart to [`Document::header`], for a caller
    /// that has to set a header field a layer above it owns —
    /// the session id, which the SECC assigns and neither side
    /// chooses per message.
    pub const fn header_mut(&mut self) -> Option<&mut super::common::MessageHeader> {
        match self {
            Self::DCCableCheckReq(m) => Some(&mut m.header),
            Self::DCCableCheckRes(m) => Some(&mut m.header),
            Self::DCChargeLoopReq(m) => Some(&mut m.header),
            Self::DCChargeLoopRes(m) => Some(&mut m.header),
            Self::DCChargeParameterDiscoveryReq(m) => Some(&mut m.header),
            Self::DCChargeParameterDiscoveryRes(m) => Some(&mut m.header),
            Self::DCPreChargeReq(m) => Some(&mut m.header),
            Self::DCPreChargeRes(m) => Some(&mut m.header),
            Self::DCWeldingDetectionReq(m) => Some(&mut m.header),
            Self::DCWeldingDetectionRes(m) => Some(&mut m.header),
            _ => None,
        }
    }
}

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

impl Document {
    /// The response that refuses this request, carrying
    /// `code`.
    ///
    /// Every other field is the schema's minimum, so
    /// this always encodes. A station answering a
    /// sequence error has to send the matching response
    /// type, and usually has nothing to put in one.
    ///
    /// `None` when this is already a response.
    #[must_use]
    pub fn refusal(&self, code: super::common::ResponseCode) -> Option<Self> {
        Some(match self {
            Self::DCCableCheckReq(_) => Self::DCCableCheckRes(DCCableCheckRes {
                response_code: code,
                ..DCCableCheckRes::minimal()
            }),
            Self::DCChargeLoopReq(_) => Self::DCChargeLoopRes(DCChargeLoopRes {
                response_code: code,
                ..DCChargeLoopRes::minimal()
            }),
            Self::DCChargeParameterDiscoveryReq(_) => {
                Self::DCChargeParameterDiscoveryRes(DCChargeParameterDiscoveryRes {
                    response_code: code,
                    ..DCChargeParameterDiscoveryRes::minimal()
                })
            }
            Self::DCPreChargeReq(_) => Self::DCPreChargeRes(DCPreChargeRes {
                response_code: code,
                ..DCPreChargeRes::minimal()
            }),
            Self::DCWeldingDetectionReq(_) => Self::DCWeldingDetectionRes(DCWeldingDetectionRes {
                response_code: code,
                ..DCWeldingDetectionRes::minimal()
            }),
            _ => return None,
        })
    }
}

impl Document {
    /// The *fragment* event code of this message.
    ///
    /// See [`FRAGMENT_WIDTH`] for why this differs from
    /// [`Document::code`].
    #[must_use]
    pub const fn fragment_code(&self) -> u64 {
        match self {
            Self::BPTDCCPDReqEnergyTransferMode(_) => 3,
            Self::BPTDCCPDResEnergyTransferMode(_) => 4,
            Self::BPTDynamicDCCLReqControlMode(_) => 6,
            Self::BPTDynamicDCCLResControlMode(_) => 7,
            Self::BPTScheduledDCCLReqControlMode(_) => 9,
            Self::BPTScheduledDCCLResControlMode(_) => 10,
            Self::DCCPDReqEnergyTransferMode(_) => 19,
            Self::DCCPDResEnergyTransferMode(_) => 20,
            Self::DCCableCheckReq(_) => 21,
            Self::DCCableCheckRes(_) => 22,
            Self::DCChargeLoopReq(_) => 23,
            Self::DCChargeLoopRes(_) => 24,
            Self::DCChargeParameterDiscoveryReq(_) => 25,
            Self::DCChargeParameterDiscoveryRes(_) => 26,
            Self::DCPreChargeReq(_) => 27,
            Self::DCPreChargeRes(_) => 28,
            Self::DCWeldingDetectionReq(_) => 29,
            Self::DCWeldingDetectionRes(_) => 30,
            Self::DynamicDCCLReqControlMode(_) => 36,
            Self::DynamicDCCLResControlMode(_) => 37,
            Self::ScheduledDCCLReqControlMode(_) => 120,
            Self::ScheduledDCCLResControlMode(_) => 121,
        }
    }

    /// Encodes this message as a standalone EXI fragment.
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(self.fragment_code(), FRAGMENT_WIDTH)?;
        match self {
            Self::BPTDCCPDReqEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::BPTDCCPDResEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::BPTDynamicDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::BPTDynamicDCCLResControlMode(m) => m.encode_body(&mut e)?,
            Self::BPTScheduledDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::BPTScheduledDCCLResControlMode(m) => m.encode_body(&mut e)?,
            Self::DCCPDReqEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::DCCPDResEnergyTransferMode(m) => m.encode_body(&mut e)?,
            Self::DCCableCheckReq(m) => m.encode_body(&mut e)?,
            Self::DCCableCheckRes(m) => m.encode_body(&mut e)?,
            Self::DCChargeLoopReq(m) => m.encode_body(&mut e)?,
            Self::DCChargeLoopRes(m) => m.encode_body(&mut e)?,
            Self::DCChargeParameterDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::DCChargeParameterDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::DCPreChargeReq(m) => m.encode_body(&mut e)?,
            Self::DCPreChargeRes(m) => m.encode_body(&mut e)?,
            Self::DCWeldingDetectionReq(m) => m.encode_body(&mut e)?,
            Self::DCWeldingDetectionRes(m) => m.encode_body(&mut e)?,
            Self::DynamicDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::DynamicDCCLResControlMode(m) => m.encode_body(&mut e)?,
            Self::ScheduledDCCLReqControlMode(m) => m.encode_body(&mut e)?,
            Self::ScheduledDCCLResControlMode(m) => m.encode_body(&mut e)?,
        }
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

    /// Encodes this message as a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

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

    /// The same, under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

    /// 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)? {
            3 => Self::BPTDCCPDReqEnergyTransferMode(BPTDCCPDReqEnergyTransferMode::decode_body(
                &mut d,
            )?),
            4 => Self::BPTDCCPDResEnergyTransferMode(BPTDCCPDResEnergyTransferMode::decode_body(
                &mut d,
            )?),
            6 => Self::BPTDynamicDCCLReqControlMode(BPTDynamicDCCLReqControlMode::decode_body(
                &mut d,
            )?),
            7 => Self::BPTDynamicDCCLResControlMode(BPTDynamicDCCLResControlMode::decode_body(
                &mut d,
            )?),
            9 => Self::BPTScheduledDCCLReqControlMode(BPTScheduledDCCLReqControlMode::decode_body(
                &mut d,
            )?),
            10 => Self::BPTScheduledDCCLResControlMode(
                BPTScheduledDCCLResControlMode::decode_body(&mut d)?,
            ),
            19 => {
                Self::DCCPDReqEnergyTransferMode(DCCPDReqEnergyTransferMode::decode_body(&mut d)?)
            }
            20 => {
                Self::DCCPDResEnergyTransferMode(DCCPDResEnergyTransferMode::decode_body(&mut d)?)
            }
            21 => Self::DCCableCheckReq(DCCableCheckReq::decode_body(&mut d)?),
            22 => Self::DCCableCheckRes(DCCableCheckRes::decode_body(&mut d)?),
            23 => Self::DCChargeLoopReq(DCChargeLoopReq::decode_body(&mut d)?),
            24 => Self::DCChargeLoopRes(DCChargeLoopRes::decode_body(&mut d)?),
            25 => Self::DCChargeParameterDiscoveryReq(DCChargeParameterDiscoveryReq::decode_body(
                &mut d,
            )?),
            26 => Self::DCChargeParameterDiscoveryRes(DCChargeParameterDiscoveryRes::decode_body(
                &mut d,
            )?),
            27 => Self::DCPreChargeReq(DCPreChargeReq::decode_body(&mut d)?),
            28 => Self::DCPreChargeRes(DCPreChargeRes::decode_body(&mut d)?),
            29 => Self::DCWeldingDetectionReq(DCWeldingDetectionReq::decode_body(&mut d)?),
            30 => Self::DCWeldingDetectionRes(DCWeldingDetectionRes::decode_body(&mut d)?),
            36 => Self::DynamicDCCLReqControlMode(DynamicDCCLReqControlMode::decode_body(&mut d)?),
            37 => Self::DynamicDCCLResControlMode(DynamicDCCLResControlMode::decode_body(&mut d)?),
            120 => {
                Self::ScheduledDCCLReqControlMode(ScheduledDCCLReqControlMode::decode_body(&mut d)?)
            }
            121 => {
                Self::ScheduledDCCLResControlMode(ScheduledDCCLResControlMode::decode_body(&mut d)?)
            }
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(BPT_DC_CPDReqEnergyTransferMode) … 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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(BPT_DC_CPDResEnergyTransferMode) … 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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

    /// 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 BPTDynamicDCCLReqControlMode {
    /// Fragment event code of `BPT_Dynamic_DC_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(BPT_Dynamic_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

    /// 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 BPTDynamicDCCLResControlMode {
    /// Fragment event code of `BPT_Dynamic_DC_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(BPT_Dynamic_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(BPT_Scheduled_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(BPT_Scheduled_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_CPDReqEnergyTransferMode) … 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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_CPDResEnergyTransferMode) … 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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

    /// 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 DCCableCheckReq {
    /// Fragment event code of `DC_CableCheckReq` 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(DC_CableCheckReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_CableCheckRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_ChargeLoopReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_ChargeLoopRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_ChargeParameterDiscoveryReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_ChargeParameterDiscoveryRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_PreChargeReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

    /// 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 DCPreChargeRes {
    /// Fragment event code of `DC_PreChargeRes` 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(DC_PreChargeRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_WeldingDetectionReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(DC_WeldingDetectionRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Dynamic_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

    /// 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 DynamicDCCLResControlMode {
    /// Fragment event code of `Dynamic_DC_CLResControlMode` 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(Dynamic_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Scheduled_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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

    /// Encodes this element as a standalone EXI *fragment*
    /// (EXI 1.0 §8.5.2) against this schema set.
    ///
    /// A fragment is `SD SE(Scheduled_DC_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.
    ///
    /// `coding` decides how a repeated string value is written; the
    /// interoperable default is [`ValueCoding::Literal`].
    pub fn encode_fragment_with(&self, buf: &mut [u8], coding: ValueCoding) -> ExiResult<usize> {
        let mut e = Encoder::with_value_coding(buf, coding);
        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 a standalone EXI fragment,
    /// every value written in full.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        self.encode_fragment_with(buf, ValueCoding::Literal)
    }

    /// Encodes this element as an EXI fragment into a vector,
    /// under an explicit [`ValueCoding`].
    pub fn to_fragment_with(&self, coding: ValueCoding) -> ExiResult<Vec<u8>> {
        crate::exi::encode_growing(|buf| self.encode_fragment_with(buf, coding))
    }

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