iso15118 0.2.0

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

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

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

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

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

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

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

impl ACDPConnectReq {
    /// 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 = ElectricalChargingDeviceStatus::from_index(
                        d.nbit(ElectricalChargingDeviceStatus::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_electrical_charging_device_status: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ACDP_ConnectResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACDPConnectRes {
    /// `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,
    /// `EVSEElectricalChargingDeviceStatus` element, 1..1.
    pub evse_electrical_charging_device_status: ElectricalChargingDeviceStatus,
    /// `EVSEMechanicalChargingDeviceStatus` element, 1..1.
    pub evse_mechanical_charging_device_status: MechanicalChargingDeviceStatus,
}

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

impl ACDPConnectRes {
    /// 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);
        }
        // EVSEElectricalChargingDeviceStatus (1..1)
        {
            let item = &self.evse_electrical_charging_device_status;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ElectricalChargingDeviceStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // EVSEMechanicalChargingDeviceStatus (1..1)
        {
            let item = &self.evse_mechanical_charging_device_status;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), MechanicalChargingDeviceStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

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

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

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

/// `ACDP_SystemStatusResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACDPSystemStatusRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEMechanicalChargingDeviceStatus` element, 1..1.
    pub evse_mechanical_charging_device_status: MechanicalChargingDeviceStatus,
    /// `EVSEReadyToCharge` element, 1..1.
    pub evse_ready_to_charge: bool,
    /// `EVSEIsolationStatus` element, 1..1.
    pub evse_isolation_status: IsolationStatus,
    /// `EVSEDisabled` element, 1..1.
    pub evse_disabled: bool,
    /// `EVSEUtilityInterruptEvent` element, 1..1.
    pub evse_utility_interrupt_event: bool,
    /// `EVSEEmergencyShutdown` element, 1..1.
    pub evse_emergency_shutdown: bool,
    /// `EVSEMalfunction` element, 1..1.
    pub evse_malfunction: bool,
    /// `EVInChargePosition` element, 1..1.
    pub ev_in_charge_position: bool,
    /// `EVAssociationStatus` element, 1..1.
    pub ev_association_status: bool,
}

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

impl ACDPSystemStatusRes {
    /// 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);
        }
        // EVSEMechanicalChargingDeviceStatus (1..1)
        {
            let item = &self.evse_mechanical_charging_device_status;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), MechanicalChargingDeviceStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVSEReadyToCharge (1..1)
        {
            let item = &self.evse_ready_to_charge;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // EVSEIsolationStatus (1..1)
        {
            let item = &self.evse_isolation_status;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), IsolationStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // EVSEDisabled (1..1)
        {
            let item = &self.evse_disabled;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // EVSEUtilityInterruptEvent (1..1)
        {
            let item = &self.evse_utility_interrupt_event;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // EVSEEmergencyShutdown (1..1)
        {
            let item = &self.evse_emergency_shutdown;
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 1);
        }
        // EVSEMalfunction (1..1)
        {
            let item = &self.evse_malfunction;
            w.start(e, 8, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(8, 1);
        }
        // EVInChargePosition (1..1)
        {
            let item = &self.ev_in_charge_position;
            w.start(e, 9, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(9, 1);
        }
        // EVAssociationStatus (1..1)
        {
            let item = &self.ev_association_status;
            w.start(e, 10, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(10, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ACDPSystemStatusRes {
    /// 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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = MechanicalChargingDeviceStatus::from_index(
                        d.nbit(MechanicalChargingDeviceStatus::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = IsolationStatus::from_index(d.nbit(IsolationStatus::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    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_mechanical_charging_device_status: f_2.ok_or(ExiError::MissingElement)?,
            evse_ready_to_charge: f_3.ok_or(ExiError::MissingElement)?,
            evse_isolation_status: f_4.ok_or(ExiError::MissingElement)?,
            evse_disabled: f_5.ok_or(ExiError::MissingElement)?,
            evse_utility_interrupt_event: f_6.ok_or(ExiError::MissingElement)?,
            evse_emergency_shutdown: f_7.ok_or(ExiError::MissingElement)?,
            evse_malfunction: f_8.ok_or(ExiError::MissingElement)?,
            ev_in_charge_position: f_9.ok_or(ExiError::MissingElement)?,
            ev_association_status: f_10.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ACDP_VehiclePositioningReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACDPVehiclePositioningReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVMobilityStatus` element, 1..1.
    pub ev_mobility_status: bool,
    /// `EVPositioningSupport` element, 1..1.
    pub ev_positioning_support: bool,
}

impl ACDPVehiclePositioningReq {
    /// 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 ACDPVehiclePositioningReq {
    /// 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);
        }
        // EVMobilityStatus (1..1)
        {
            let item = &self.ev_mobility_status;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVPositioningSupport (1..1)
        {
            let item = &self.ev_positioning_support;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `ACDP_VehiclePositioningResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ACDPVehiclePositioningRes {
    /// `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,
    /// `EVSEPositioningSupport` element, 1..1.
    pub evse_positioning_support: bool,
    /// `EVRelativeXDeviation` element, 1..1.
    pub ev_relative_x_deviation: i16,
    /// `EVRelativeYDeviation` element, 1..1.
    pub ev_relative_y_deviation: i16,
    /// `ContactWindowXc` element, 1..1.
    pub contact_window_xc: i16,
    /// `ContactWindowYc` element, 1..1.
    pub contact_window_yc: i16,
    /// `EVInChargePosition` element, 1..1.
    pub ev_in_charge_position: bool,
}

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

impl ACDPVehiclePositioningRes {
    /// 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);
        }
        // EVSEPositioningSupport (1..1)
        {
            let item = &self.evse_positioning_support;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // EVRelativeXDeviation (1..1)
        {
            let item = &self.ev_relative_x_deviation;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // EVRelativeYDeviation (1..1)
        {
            let item = &self.ev_relative_y_deviation;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // ContactWindowXc (1..1)
        {
            let item = &self.contact_window_xc;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // ContactWindowYc (1..1)
        {
            let item = &self.contact_window_yc;
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 1);
        }
        // EVInChargePosition (1..1)
        {
            let item = &self.ev_in_charge_position;
            w.start(e, 8, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(8, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ACDPVehiclePositioningRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        let mut f_8 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    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 { .. } => 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)?,
            evse_positioning_support: f_3.ok_or(ExiError::MissingElement)?,
            ev_relative_x_deviation: f_4.ok_or(ExiError::MissingElement)?,
            ev_relative_y_deviation: f_5.ok_or(ExiError::MissingElement)?,
            contact_window_xc: f_6.ok_or(ExiError::MissingElement)?,
            contact_window_yc: f_7.ok_or(ExiError::MissingElement)?,
            ev_in_charge_position: f_8.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `EVTechnicalStatusType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVTechnicalStatus {
    /// `EVReadyToCharge` element, 1..1.
    pub ev_ready_to_charge: bool,
    /// `EVImmobilizationRequest` element, 1..1.
    pub ev_immobilization_request: bool,
    /// `EVImmobilized` element, 0..1.
    pub ev_immobilized: Option<bool>,
    /// `EVWLANStrength` element, 0..1.
    pub ev_wlan_strength: Option<super::common::RationalNumber>,
    /// `EVCPStatus` element, 0..1.
    pub ev_cp_status: Option<CpStatus>,
    /// `EVSOC` element, 0..1.
    pub ev_soc: Option<u8>,
    /// `EVErrorCode` element, 0..1.
    pub ev_error_code: Option<ErrorCode>,
    /// `EVTimeout` element, 0..1.
    pub ev_timeout: Option<bool>,
}

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

impl EVTechnicalStatus {
    /// 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);
        // EVReadyToCharge (1..1)
        {
            let item = &self.ev_ready_to_charge;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // EVImmobilizationRequest (1..1)
        {
            let item = &self.ev_immobilization_request;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVImmobilized (0..1)
        if let Some(item) = &self.ev_immobilized {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVWLANStrength (0..1)
        if let Some(item) = &self.ev_wlan_strength {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVCPStatus (0..1)
        if let Some(item) = &self.ev_cp_status {
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), CpStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // EVSOC (0..1)
        if let Some(item) = &self.ev_soc {
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 100)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // EVErrorCode (0..1)
        if let Some(item) = &self.ev_error_code {
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ErrorCode::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // EVTimeout (0..1)
        if let Some(item) = &self.ev_timeout {
            w.start(e, 7, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(7, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl EVTechnicalStatus {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        let mut f_6 = None;
        let mut f_7 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = CpStatus::from_index(d.nbit(CpStatus::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    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_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ErrorCode::from_index(d.nbit(ErrorCode::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_7 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            ev_ready_to_charge: f_0.ok_or(ExiError::MissingElement)?,
            ev_immobilization_request: f_1.ok_or(ExiError::MissingElement)?,
            ev_immobilized: f_2,
            ev_wlan_strength: f_3,
            ev_cp_status: f_4,
            ev_soc: f_5,
            ev_error_code: f_6,
            ev_timeout: f_7,
        })
    }
}

/// `cpStatusType`.
///
/// 5 values, so 3 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum CpStatus {
    /// `StateA`
    StateA = 0,
    /// `StateB`
    StateB = 1,
    /// `StateC`
    StateC = 2,
    /// `StateD`
    StateD = 3,
    /// `StateE`
    StateE = 4,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 5] =
        [Self::StateA, Self::StateB, Self::StateC, Self::StateD, Self::StateE];

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

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::StateA,
            1 => Self::StateB,
            2 => Self::StateC,
            3 => Self::StateD,
            4 => Self::StateE,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

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

/// `electricalChargingDeviceStatusType`.
///
/// 4 values, so 2 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum ElectricalChargingDeviceStatus {
    /// `State_A`
    StateA = 0,
    /// `State_B`
    StateB = 1,
    /// `State_C`
    StateC = 2,
    /// `State_D`
    StateD = 3,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 4] = [Self::StateA, Self::StateB, Self::StateC, Self::StateD];

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

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

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::StateA => "State_A",
            Self::StateB => "State_B",
            Self::StateC => "State_C",
            Self::StateD => "State_D",
        }
    }
}

/// `errorCodeType`.
///
/// 10 values, so 4 bits. Discriminants are the EXI indices, which
/// follow schema document order rather than sort order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(u16)]
pub enum ErrorCode {
    /// `OK_NoEVError`
    OKNoEVError = 0,
    /// `FAILED`
    FAILED = 1,
    /// `FAILED_EmergencyEvent`
    FAILEDEmergencyEvent = 2,
    /// `FAILED_Breaker`
    FAILEDBreaker = 3,
    /// `FAILED_RESSTemperatureInhibit`
    FAILEDRESSTemperatureInhibit = 4,
    /// `FAILED_RESS`
    FAILEDRESS = 5,
    /// `FAILED_ChargingCurrentDifferential`
    FAILEDChargingCurrentDifferential = 6,
    /// `FAILED_ChargingVoltageOutOfRange`
    FAILEDChargingVoltageOutOfRange = 7,
    /// `FAILED_Reserved1`
    FAILEDReserved1 = 8,
    /// `FAILED_Reserved2`
    FAILEDReserved2 = 9,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 10] = [
        Self::OKNoEVError,
        Self::FAILED,
        Self::FAILEDEmergencyEvent,
        Self::FAILEDBreaker,
        Self::FAILEDRESSTemperatureInhibit,
        Self::FAILEDRESS,
        Self::FAILEDChargingCurrentDifferential,
        Self::FAILEDChargingVoltageOutOfRange,
        Self::FAILEDReserved1,
        Self::FAILEDReserved2,
    ];

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

    /// Parses an EXI index.
    pub const fn from_index(index: u64) -> ExiResult<Self> {
        Ok(match index {
            0 => Self::OKNoEVError,
            1 => Self::FAILED,
            2 => Self::FAILEDEmergencyEvent,
            3 => Self::FAILEDBreaker,
            4 => Self::FAILEDRESSTemperatureInhibit,
            5 => Self::FAILEDRESS,
            6 => Self::FAILEDChargingCurrentDifferential,
            7 => Self::FAILEDChargingVoltageOutOfRange,
            8 => Self::FAILEDReserved1,
            9 => Self::FAILEDReserved2,
            _ => return Err(ExiError::UnknownEnumValue),
        })
    }

    /// The lexical form this value has in the schema.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::OKNoEVError => "OK_NoEVError",
            Self::FAILED => "FAILED",
            Self::FAILEDEmergencyEvent => "FAILED_EmergencyEvent",
            Self::FAILEDBreaker => "FAILED_Breaker",
            Self::FAILEDRESSTemperatureInhibit => "FAILED_RESSTemperatureInhibit",
            Self::FAILEDRESS => "FAILED_RESS",
            Self::FAILEDChargingCurrentDifferential => "FAILED_ChargingCurrentDifferential",
            Self::FAILEDChargingVoltageOutOfRange => "FAILED_ChargingVoltageOutOfRange",
            Self::FAILEDReserved1 => "FAILED_Reserved1",
            Self::FAILEDReserved2 => "FAILED_Reserved2",
        }
    }
}

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

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

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

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

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

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

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

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::Home, Self::Moving, Self::EndPosition];

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

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

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

/// Width of a document-level event code.
///
/// One alternative per global element in the schema set — 34 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 — 129 here, against the 34
/// 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 = 130;

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

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

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

impl ACDPSystemStatusRes {
    /// Document event code of `ACDP_SystemStatusRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 5;
}

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

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

impl ACDPVehiclePositioningReq {
    /// Document event code of `ACDP_VehiclePositioningReq` in this schema set.
    pub const DOCUMENT_CODE: u64 = 6;
}

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

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

impl ACDPVehiclePositioningRes {
    /// Document event code of `ACDP_VehiclePositioningRes` in this schema set.
    pub const DOCUMENT_CODE: u64 = 7;
}

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

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

/// Any document this schema set defines.
///
/// The document event code says which message a stream holds, so
/// this is what a peer decodes into before it knows what it got.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub enum Document {
    /// `ACDP_ConnectReq`
    ACDPConnectReq(ACDPConnectReq),
    /// `ACDP_ConnectRes`
    ACDPConnectRes(ACDPConnectRes),
    /// `ACDP_DisconnectReq`
    ACDPDisconnectReq(ACDPConnectReq),
    /// `ACDP_DisconnectRes`
    ACDPDisconnectRes(ACDPConnectRes),
    /// `ACDP_SystemStatusReq`
    ACDPSystemStatusReq(ACDPSystemStatusReq),
    /// `ACDP_SystemStatusRes`
    ACDPSystemStatusRes(ACDPSystemStatusRes),
    /// `ACDP_VehiclePositioningReq`
    ACDPVehiclePositioningReq(ACDPVehiclePositioningReq),
    /// `ACDP_VehiclePositioningRes`
    ACDPVehiclePositioningRes(ACDPVehiclePositioningRes),
}

impl Document {
    /// The element name of this document.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::ACDPConnectReq(_) => "ACDP_ConnectReq",
            Self::ACDPConnectRes(_) => "ACDP_ConnectRes",
            Self::ACDPDisconnectReq(_) => "ACDP_DisconnectReq",
            Self::ACDPDisconnectRes(_) => "ACDP_DisconnectRes",
            Self::ACDPSystemStatusReq(_) => "ACDP_SystemStatusReq",
            Self::ACDPSystemStatusRes(_) => "ACDP_SystemStatusRes",
            Self::ACDPVehiclePositioningReq(_) => "ACDP_VehiclePositioningReq",
            Self::ACDPVehiclePositioningRes(_) => "ACDP_VehiclePositioningRes",
        }
    }

    /// The document event code of this message.
    #[must_use]
    pub const fn code(&self) -> u64 {
        match self {
            Self::ACDPConnectReq(_) => 0,
            Self::ACDPConnectRes(_) => 1,
            Self::ACDPDisconnectReq(_) => 2,
            Self::ACDPDisconnectRes(_) => 3,
            Self::ACDPSystemStatusReq(_) => 4,
            Self::ACDPSystemStatusRes(_) => 5,
            Self::ACDPVehiclePositioningReq(_) => 6,
            Self::ACDPVehiclePositioningRes(_) => 7,
        }
    }
}

impl crate::exi::ExiDocument for Document {
    fn to_slice(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(self.code(), DOCUMENT_WIDTH)?;
        match self {
            Self::ACDPConnectReq(m) => m.encode_body(&mut e)?,
            Self::ACDPConnectRes(m) => m.encode_body(&mut e)?,
            Self::ACDPDisconnectReq(m) => m.encode_body(&mut e)?,
            Self::ACDPDisconnectRes(m) => m.encode_body(&mut e)?,
            Self::ACDPSystemStatusReq(m) => m.encode_body(&mut e)?,
            Self::ACDPSystemStatusRes(m) => m.encode_body(&mut e)?,
            Self::ACDPVehiclePositioningReq(m) => m.encode_body(&mut e)?,
            Self::ACDPVehiclePositioningRes(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::ACDPConnectReq(ACDPConnectReq::decode_body(&mut d)?),
            1 => Self::ACDPConnectRes(ACDPConnectRes::decode_body(&mut d)?),
            2 => Self::ACDPDisconnectReq(ACDPConnectReq::decode_body(&mut d)?),
            3 => Self::ACDPDisconnectRes(ACDPConnectRes::decode_body(&mut d)?),
            4 => Self::ACDPSystemStatusReq(ACDPSystemStatusReq::decode_body(&mut d)?),
            5 => Self::ACDPSystemStatusRes(ACDPSystemStatusRes::decode_body(&mut d)?),
            6 => Self::ACDPVehiclePositioningReq(ACDPVehiclePositioningReq::decode_body(&mut d)?),
            7 => Self::ACDPVehiclePositioningRes(ACDPVehiclePositioningRes::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::ACDPConnectReq(m) => Some(&m.header),
            Self::ACDPConnectRes(m) => Some(&m.header),
            Self::ACDPDisconnectReq(m) => Some(&m.header),
            Self::ACDPDisconnectRes(m) => Some(&m.header),
            Self::ACDPSystemStatusReq(m) => Some(&m.header),
            Self::ACDPSystemStatusRes(m) => Some(&m.header),
            Self::ACDPVehiclePositioningReq(m) => Some(&m.header),
            Self::ACDPVehiclePositioningRes(m) => Some(&m.header),
        }
    }

    /// The message header, mutably.
    ///
    /// The counterpart to [`Document::header`], for a caller
    /// that has to set a header field a layer above it owns —
    /// the session id, which the SECC assigns and neither side
    /// chooses per message.
    pub const fn header_mut(&mut self) -> Option<&mut super::common::MessageHeader> {
        match self {
            Self::ACDPConnectReq(m) => Some(&mut m.header),
            Self::ACDPConnectRes(m) => Some(&mut m.header),
            Self::ACDPDisconnectReq(m) => Some(&mut m.header),
            Self::ACDPDisconnectRes(m) => Some(&mut m.header),
            Self::ACDPSystemStatusReq(m) => Some(&mut m.header),
            Self::ACDPSystemStatusRes(m) => Some(&mut m.header),
            Self::ACDPVehiclePositioningReq(m) => Some(&mut m.header),
            Self::ACDPVehiclePositioningRes(m) => Some(&mut m.header),
        }
    }
}

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

impl Document {
    /// The *fragment* event code of this message.
    ///
    /// See [`FRAGMENT_WIDTH`] for why this differs from
    /// [`Document::code`].
    #[must_use]
    pub const fn fragment_code(&self) -> u64 {
        match self {
            Self::ACDPConnectReq(_) => 0,
            Self::ACDPConnectRes(_) => 1,
            Self::ACDPDisconnectReq(_) => 2,
            Self::ACDPDisconnectRes(_) => 3,
            Self::ACDPSystemStatusReq(_) => 4,
            Self::ACDPSystemStatusRes(_) => 5,
            Self::ACDPVehiclePositioningReq(_) => 6,
            Self::ACDPVehiclePositioningRes(_) => 7,
        }
    }

    /// Encodes this message as a standalone EXI fragment.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(self.fragment_code(), FRAGMENT_WIDTH)?;
        match self {
            Self::ACDPConnectReq(m) => m.encode_body(&mut e)?,
            Self::ACDPConnectRes(m) => m.encode_body(&mut e)?,
            Self::ACDPDisconnectReq(m) => m.encode_body(&mut e)?,
            Self::ACDPDisconnectRes(m) => m.encode_body(&mut e)?,
            Self::ACDPSystemStatusReq(m) => m.encode_body(&mut e)?,
            Self::ACDPSystemStatusRes(m) => m.encode_body(&mut e)?,
            Self::ACDPVehiclePositioningReq(m) => m.encode_body(&mut e)?,
            Self::ACDPVehiclePositioningRes(m) => m.encode_body(&mut e)?,
        }
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

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

    /// Parses a message from a standalone EXI fragment.
    pub fn from_fragment(bytes: &[u8]) -> ExiResult<Self> {
        let mut d = Decoder::new(bytes);
        d.read_header()?;
        let value = match d.event(FRAGMENT_WIDTH)? {
            0 => Self::ACDPConnectReq(ACDPConnectReq::decode_body(&mut d)?),
            1 => Self::ACDPConnectRes(ACDPConnectRes::decode_body(&mut d)?),
            2 => Self::ACDPDisconnectReq(ACDPConnectReq::decode_body(&mut d)?),
            3 => Self::ACDPDisconnectRes(ACDPConnectRes::decode_body(&mut d)?),
            4 => Self::ACDPSystemStatusReq(ACDPSystemStatusReq::decode_body(&mut d)?),
            5 => Self::ACDPSystemStatusRes(ACDPSystemStatusRes::decode_body(&mut d)?),
            6 => Self::ACDPVehiclePositioningReq(ACDPVehiclePositioningReq::decode_body(&mut d)?),
            7 => Self::ACDPVehiclePositioningRes(ACDPVehiclePositioningRes::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

impl ACDPSystemStatusReq {
    /// Fragment event code of `ACDP_SystemStatusReq` 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(ACDP_SystemStatusReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

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

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

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

impl ACDPVehiclePositioningReq {
    /// Fragment event code of `ACDP_VehiclePositioningReq` 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(ACDP_VehiclePositioningReq) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

impl ACDPVehiclePositioningRes {
    /// Fragment event code of `ACDP_VehiclePositioningRes` 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(ACDP_VehiclePositioningRes) … EE ED`: the same element
    /// body as a document, under a different root table. This is
    /// the form an ISO 15118 signature is computed over.
    pub fn encode_fragment(&self, buf: &mut [u8]) -> ExiResult<usize> {
        let mut e = Encoder::new(buf);
        e.write_header(crate::exi::Header::ISO15118)?;
        e.event(Self::FRAGMENT_CODE, FRAGMENT_WIDTH)?;
        self.encode_body(&mut e)?;
        e.event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        e.finish()
    }

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

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

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

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

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

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