iso15118 0.2.0

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

/// `AbsolutePriceScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AbsolutePriceSchedule {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `PriceScheduleID` element, 1..1.
    pub price_schedule_id: u32,
    /// `PriceScheduleDescription` element, 0..1.
    pub price_schedule_description: Option<String>,
    /// `Currency` element, 1..1.
    pub currency: String,
    /// `Language` element, 1..1.
    pub language: String,
    /// `PriceAlgorithm` element, 1..1.
    pub price_algorithm: String,
    /// `MinimumCost` element, 0..1.
    pub minimum_cost: Option<super::common::RationalNumber>,
    /// `MaximumCost` element, 0..1.
    pub maximum_cost: Option<super::common::RationalNumber>,
    /// `TaxRules` element, 0..1.
    pub tax_rules: Option<TaxRuleList>,
    /// `PriceRuleStacks` element, 1..1.
    pub price_rule_stacks: PriceRuleStackList,
    /// `OverstayRules` element, 0..1.
    pub overstay_rules: Option<OverstayRuleList>,
    /// `AdditionalSelectedServices` element, 0..1.
    pub additional_selected_services: Option<AdditionalServiceList>,
}

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

impl AbsolutePriceSchedule {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(92), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PriceScheduleID (1..1)
        {
            let item = &self.price_schedule_id;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // PriceScheduleDescription (0..1)
        if let Some(item) = &self.price_schedule_description {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(153), item, Lengths::max(160))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // Currency (1..1)
        {
            let item = &self.currency;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(31), item, Lengths::max(3))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // Language (1..1)
        {
            let item = &self.language;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(95), item, Lengths::max(3))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // PriceAlgorithm (1..1)
        {
            let item = &self.price_algorithm;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(145), item, Lengths::max(255))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // MinimumCost (0..1)
        if let Some(item) = &self.minimum_cost {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        // MaximumCost (0..1)
        if let Some(item) = &self.maximum_cost {
            w.start(e, 8, 0)?;
            item.encode_body(e)?;
            w.finish(8, 1);
        }
        // TaxRules (0..1)
        if let Some(item) = &self.tax_rules {
            w.start(e, 9, 0)?;
            item.encode_body(e)?;
            w.finish(9, 1);
        }
        // PriceRuleStacks (1..1)
        {
            let item = &self.price_rule_stacks;
            w.start(e, 10, 0)?;
            item.encode_body(e)?;
            w.finish(10, 1);
        }
        // OverstayRules (0..1)
        if let Some(item) = &self.overstay_rules {
            w.start(e, 11, 0)?;
            item.encode_body(e)?;
            w.finish(11, 1);
        }
        // AdditionalSelectedServices (0..1)
        if let Some(item) = &self.additional_selected_services {
            w.start(e, 12, 0)?;
            item.encode_body(e)?;
            w.finish(12, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl AbsolutePriceSchedule {
    /// 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 = d.string(ValueCtx(92), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u64::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(153), Lengths::max(160))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(31), Lengths::max(3))?;
                    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.string(ValueCtx(95), Lengths::max(3))?;
                    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.string(ValueCtx(145), Lengths::max(255))?;
                    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 = TaxRuleList::decode_body(d)?;
                    f_9 = Some(value);
                }
                Step::Item { index: 10, .. } => {
                    let value = PriceRuleStackList::decode_body(d)?;
                    f_10 = Some(value);
                }
                Step::Item { index: 11, .. } => {
                    let value = OverstayRuleList::decode_body(d)?;
                    f_11 = Some(value);
                }
                Step::Item { index: 12, .. } => {
                    let value = AdditionalServiceList::decode_body(d)?;
                    f_12 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            time_anchor: f_1.ok_or(ExiError::MissingElement)?,
            price_schedule_id: f_2.ok_or(ExiError::MissingElement)?,
            price_schedule_description: f_3,
            currency: f_4.ok_or(ExiError::MissingElement)?,
            language: f_5.ok_or(ExiError::MissingElement)?,
            price_algorithm: f_6.ok_or(ExiError::MissingElement)?,
            minimum_cost: f_7,
            maximum_cost: f_8,
            tax_rules: f_9,
            price_rule_stacks: f_10.ok_or(ExiError::MissingElement)?,
            overstay_rules: f_11,
            additional_selected_services: f_12,
        })
    }
}

/// `AdditionalServiceListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AdditionalServiceList {
    /// `AdditionalService` element, 1..5.
    pub additional_service: Vec<AdditionalService>,
}

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

impl AdditionalServiceList {
    /// 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);
        // AdditionalService (1..5)
        {
            let items = &self.additional_service;
            let count = items.len() as u32;
            if count < 1 || count > 5 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `AdditionalServiceType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AdditionalService {
    /// `ServiceName` element, 1..1.
    pub service_name: String,
    /// `ServiceFee` element, 1..1.
    pub service_fee: super::common::RationalNumber,
}

impl AdditionalService {
    /// 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 AdditionalService {
    /// 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);
        // ServiceName (1..1)
        {
            let item = &self.service_name;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(182), item, Lengths::max(80))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // ServiceFee (1..1)
        {
            let item = &self.service_fee;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// The `choice of 2` alternatives of [`AuthorizationReq`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AuthorizationReqChoice {
    /// `EIM_AReqAuthorizationMode`
    EIMAReqAuthorizationMode(EIMAReqAuthorizationMode),
    /// `PnC_AReqAuthorizationMode`
    PnCAReqAuthorizationMode(PnCAReqAuthorizationMode),
}

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

/// `AuthorizationReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `SelectedAuthorizationService` element, 1..1.
    pub selected_authorization_service: Authorization,
    /// `choice of 2` element, 1..1.
    pub choice: AuthorizationReqChoice,
}

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

impl AuthorizationReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        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 = Authorization::from_index(d.nbit(Authorization::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = EIMAReqAuthorizationMode::decode_body(d)?;
                            AuthorizationReqChoice::EIMAReqAuthorizationMode(value)
                        }
                        1 => {
                            let value = PnCAReqAuthorizationMode::decode_body(d)?;
                            AuthorizationReqChoice::PnCAReqAuthorizationMode(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)?,
            selected_authorization_service: f_1.ok_or(ExiError::MissingElement)?,
            choice: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `AuthorizationResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationRes {
    /// `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 AuthorizationRes {
    /// 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 AuthorizationRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // 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 AuthorizationRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        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)?,
        })
    }
}

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

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

/// The `choice of 2` alternatives of [`AuthorizationSetupRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AuthorizationSetupResChoice {
    /// `EIM_ASResAuthorizationMode`
    EIMASResAuthorizationMode(EIMASResAuthorizationMode),
    /// `PnC_ASResAuthorizationMode`
    PnCASResAuthorizationMode(PnCASResAuthorizationMode),
}

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

/// `AuthorizationSetupResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AuthorizationSetupRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `AuthorizationServices` element, 1..2.
    pub authorization_services: Vec<Authorization>,
    /// `CertificateInstallationService` element, 1..1.
    pub certificate_installation_service: bool,
    /// `choice of 2` element, 1..1.
    pub choice: AuthorizationSetupResChoice,
}

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

impl AuthorizationSetupRes {
    /// 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);
        }
        // AuthorizationServices (1..2)
        {
            let items = &self.authorization_services;
            let count = items.len() as u32;
            if count < 1 || count > 2 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 2, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.nbit(item.as_index(), Authorization::WIDTH)?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(2, count);
            }
        }
        // CertificateInstallationService (1..1)
        {
            let item = &self.certificate_installation_service;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                AuthorizationSetupResChoice::EIMASResAuthorizationMode(value) => {
                    w.start_branch(e, 4, 0, 0)?;
                    value.encode_body(e)?;
                }
                AuthorizationSetupResChoice::PnCASResAuthorizationMode(value) => {
                    w.start_branch(e, 4, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl AuthorizationSetupRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = Vec::new();
        let mut f_3 = None;
        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 = Authorization::from_index(d.nbit(Authorization::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2.push(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, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = EIMASResAuthorizationMode::decode_body(d)?;
                            AuthorizationSetupResChoice::EIMASResAuthorizationMode(value)
                        }
                        1 => {
                            let value = PnCASResAuthorizationMode::decode_body(d)?;
                            AuthorizationSetupResChoice::PnCASResAuthorizationMode(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)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            authorization_services: {
                if (f_2.len() as u32) < 1 {
                    return Err(ExiError::MissingElement);
                }
                f_2
            },
            certificate_installation_service: f_3.ok_or(ExiError::MissingElement)?,
            choice: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

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

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

impl CertificateChain {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Certificate (1..1)
        {
            let item = &self.certificate;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(1600))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SubCertificates (0..1)
        if let Some(item) = &self.sub_certificates {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `CertificateInstallationReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateInstallationReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `OEMProvisioningCertificateChain` element, 1..1.
    pub oem_provisioning_certificate_chain: SignedCertificateChain,
    /// `ListOfRootCertificateIDs` element, 1..1.
    pub list_of_root_certificate_i_ds: super::common::ListOfRootCertificateIDs,
    /// `MaximumContractCertificateChains` element, 1..1.
    pub maximum_contract_certificate_chains: u8,
    /// `PrioritizedEMAIDs` element, 0..1.
    pub prioritized_emai_ds: Option<EMAIDList>,
}

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

impl CertificateInstallationReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // OEMProvisioningCertificateChain (1..1)
        {
            let item = &self.oem_provisioning_certificate_chain;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ListOfRootCertificateIDs (1..1)
        {
            let item = &self.list_of_root_certificate_i_ds;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // MaximumContractCertificateChains (1..1)
        {
            let item = &self.maximum_contract_certificate_chains;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // PrioritizedEMAIDs (0..1)
        if let Some(item) = &self.prioritized_emai_ds {
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateInstallationReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        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 = SignedCertificateChain::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::ListOfRootCertificateIDs::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = EMAIDList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            oem_provisioning_certificate_chain: f_1.ok_or(ExiError::MissingElement)?,
            list_of_root_certificate_i_ds: f_2.ok_or(ExiError::MissingElement)?,
            maximum_contract_certificate_chains: f_3.ok_or(ExiError::MissingElement)?,
            prioritized_emai_ds: f_4,
        })
    }
}

/// `CertificateInstallationResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateInstallationRes {
    /// `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,
    /// `CPSCertificateChain` element, 1..1.
    pub cp_s_certificate_chain: CertificateChain,
    /// `SignedInstallationData` element, 1..1.
    pub signed_installation_data: SignedInstallationData,
    /// `RemainingContractCertificateChains` element, 1..1.
    pub remaining_contract_certificate_chains: u8,
}

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

impl CertificateInstallationRes {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // 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);
        }
        // CPSCertificateChain (1..1)
        {
            let item = &self.cp_s_certificate_chain;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // SignedInstallationData (1..1)
        {
            let item = &self.signed_installation_data;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // RemainingContractCertificateChains (1..1)
        {
            let item = &self.remaining_contract_certificate_chains;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl CertificateInstallationRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = CertificateChain::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = SignedInstallationData::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = 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)?,
            cp_s_certificate_chain: f_3.ok_or(ExiError::MissingElement)?,
            signed_installation_data: f_4.ok_or(ExiError::MissingElement)?,
            remaining_contract_certificate_chains: f_5.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`ChargingSchedule`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingScheduleChoice {
    /// `AbsolutePriceSchedule`
    AbsolutePriceSchedule(AbsolutePriceSchedule),
    /// `PriceLevelSchedule`
    PriceLevelSchedule(PriceLevelSchedule),
}

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

/// `ChargingScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedule {
    /// `PowerSchedule` element, 1..1.
    pub power_schedule: PowerSchedule,
    /// `choice of 2` element, 0..1.
    pub choice: Option<ChargingScheduleChoice>,
}

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

impl ChargingSchedule {
    /// 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);
        // PowerSchedule (1..1)
        {
            let item = &self.power_schedule;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // choice of 2 (0..1)
        if let Some(item) = &self.choice {
            match item {
                ChargingScheduleChoice::AbsolutePriceSchedule(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    value.encode_body(e)?;
                }
                ChargingScheduleChoice::PriceLevelSchedule(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ChargingSchedule {
    /// 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 = PowerSchedule::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = AbsolutePriceSchedule::decode_body(d)?;
                            ChargingScheduleChoice::AbsolutePriceSchedule(value)
                        }
                        1 => {
                            let value = PriceLevelSchedule::decode_body(d)?;
                            ChargingScheduleChoice::PriceLevelSchedule(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { power_schedule: f_0.ok_or(ExiError::MissingElement)?, choice: f_1 })
    }
}

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

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

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

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

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

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

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

/// `Dynamic_SEReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DynamicSEReqControlMode {
    /// `DepartureTime` element, 1..1.
    pub departure_time: u32,
    /// `MinimumSOC` element, 0..1.
    pub minimum_soc: Option<u8>,
    /// `TargetSOC` element, 0..1.
    pub target_soc: Option<u8>,
    /// `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,
    /// `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 DynamicSEReqControlMode {
    /// 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, 2, 2, 1, 1, 1, 2, 2, 1],
        repeat_width: &[0, 0, 0, 0, 0, 0, 0, 0],
        min: &[1, 0, 0, 1, 1, 1, 0, 0],
        max: &[1, 1, 1, 1, 1, 1, 1, 1],
    };
}

impl DynamicSEReqControlMode {
    /// 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 (1..1)
        {
            let 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);
        }
        // EVTargetEnergyRequest (1..1)
        {
            let item = &self.ev_target_energy_request;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // EVMaximumEnergyRequest (1..1)
        {
            let item = &self.ev_maximum_energy_request;
            w.start(e, 4, 0)?;
            item.encode_body(e)?;
            w.finish(4, 1);
        }
        // EVMinimumEnergyRequest (1..1)
        {
            let item = &self.ev_minimum_energy_request;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        // EVMaximumV2XEnergyRequest (0..1)
        if let Some(item) = &self.ev_maximum_v2_x_energy_request {
            w.start(e, 6, 0)?;
            item.encode_body(e)?;
            w.finish(6, 1);
        }
        // EVMinimumV2XEnergyRequest (0..1)
        if let Some(item) = &self.ev_minimum_v2_x_energy_request {
            w.start(e, 7, 0)?;
            item.encode_body(e)?;
            w.finish(7, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DynamicSEReqControlMode {
    /// 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, .. } => {
                    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 {
            departure_time: f_0.ok_or(ExiError::MissingElement)?,
            minimum_soc: f_1,
            target_soc: f_2,
            ev_target_energy_request: f_3.ok_or(ExiError::MissingElement)?,
            ev_maximum_energy_request: f_4.ok_or(ExiError::MissingElement)?,
            ev_minimum_energy_request: f_5.ok_or(ExiError::MissingElement)?,
            ev_maximum_v2_x_energy_request: f_6,
            ev_minimum_v2_x_energy_request: f_7,
        })
    }
}

/// The `choice of 2` alternatives of [`DynamicSEResControlMode`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DynamicSEResControlModeChoice {
    /// `AbsolutePriceSchedule`
    AbsolutePriceSchedule(AbsolutePriceSchedule),
    /// `PriceLevelSchedule`
    PriceLevelSchedule(PriceLevelSchedule),
}

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

/// `Dynamic_SEResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DynamicSEResControlMode {
    /// `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>,
    /// `choice of 2` element, 0..1.
    pub choice: Option<DynamicSEResControlModeChoice>,
}

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

impl DynamicSEResControlMode {
    /// 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);
        }
        // choice of 2 (0..1)
        if let Some(item) = &self.choice {
            match item {
                DynamicSEResControlModeChoice::AbsolutePriceSchedule(value) => {
                    w.start_branch(e, 3, 0, 0)?;
                    value.encode_body(e)?;
                }
                DynamicSEResControlModeChoice::PriceLevelSchedule(value) => {
                    w.start_branch(e, 3, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl DynamicSEResControlMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 100)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 100)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = AbsolutePriceSchedule::decode_body(d)?;
                            DynamicSEResControlModeChoice::AbsolutePriceSchedule(value)
                        }
                        1 => {
                            let value = PriceLevelSchedule::decode_body(d)?;
                            DynamicSEResControlModeChoice::PriceLevelSchedule(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self { departure_time: f_0, minimum_soc: f_1, target_soc: f_2, choice: f_3 })
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

/// `EMAIDListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EMAIDList {
    /// `EMAID` element, 1..8.
    pub emaid: Vec<String>,
}

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

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

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

/// `EVAbsolutePriceScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVAbsolutePriceSchedule {
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `Currency` element, 1..1.
    pub currency: String,
    /// `PriceAlgorithm` element, 1..1.
    pub price_algorithm: String,
    /// `EVPriceRuleStacks` element, 1..1.
    pub ev_price_rule_stacks: EVPriceRuleStackList,
}

impl EVAbsolutePriceSchedule {
    /// 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 EVAbsolutePriceSchedule {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // Currency (1..1)
        {
            let item = &self.currency;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(31), item, Lengths::max(3))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PriceAlgorithm (1..1)
        {
            let item = &self.price_algorithm;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(145), item, Lengths::max(255))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVPriceRuleStacks (1..1)
        {
            let item = &self.ev_price_rule_stacks;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `EVEnergyOfferType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVEnergyOffer {
    /// `EVPowerSchedule` element, 1..1.
    pub ev_power_schedule: EVPowerSchedule,
    /// `EVAbsolutePriceSchedule` element, 1..1.
    pub ev_absolute_price_schedule: EVAbsolutePriceSchedule,
}

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

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

/// `EVPowerProfileEntryListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPowerProfileEntryList {
    /// `EVPowerProfileEntry` element, 1..2048.
    pub ev_power_profile_entry: Vec<PowerScheduleEntry>,
}

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

impl EVPowerProfileEntryList {
    /// 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);
        // EVPowerProfileEntry (1..2048)
        {
            let items = &self.ev_power_profile_entry;
            let count = items.len() as u32;
            if count < 1 || count > 2048 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// The `choice of 2` alternatives of [`EVPowerProfile`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum EVPowerProfileChoice {
    /// `Dynamic_EVPPTControlMode`
    DynamicEVPPTControlMode(DynamicEVPPTControlMode),
    /// `Scheduled_EVPPTControlMode`
    ScheduledEVPPTControlMode(ScheduledEVPPTControlMode),
}

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

/// `EVPowerProfileType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPowerProfile {
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `choice of 2` element, 1..1.
    pub choice: EVPowerProfileChoice,
    /// `EVPowerProfileEntries` element, 1..1.
    pub ev_power_profile_entries: EVPowerProfileEntryList,
}

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

impl EVPowerProfile {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                EVPowerProfileChoice::DynamicEVPPTControlMode(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    value.encode_body(e)?;
                }
                EVPowerProfileChoice::ScheduledEVPPTControlMode(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(1, 1);
        }
        // EVPowerProfileEntries (1..1)
        {
            let item = &self.ev_power_profile_entries;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `EVPowerScheduleEntryListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPowerScheduleEntryList {
    /// `EVPowerScheduleEntry` element, 1..1024.
    pub ev_power_schedule_entry: Vec<EVPowerScheduleEntry>,
}

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

impl EVPowerScheduleEntryList {
    /// 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);
        // EVPowerScheduleEntry (1..1024)
        {
            let items = &self.ev_power_schedule_entry;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `EVPowerScheduleEntryType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPowerScheduleEntry {
    /// `Duration` element, 1..1.
    pub duration: u32,
    /// `Power` element, 1..1.
    pub power: super::common::RationalNumber,
}

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

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

/// `EVPowerScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPowerSchedule {
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `EVPowerScheduleEntries` element, 1..1.
    pub ev_power_schedule_entries: EVPowerScheduleEntryList,
}

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

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

/// `EVPriceRuleStackListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPriceRuleStackList {
    /// `EVPriceRuleStack` element, 1..1024.
    pub ev_price_rule_stack: Vec<EVPriceRuleStack>,
}

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

impl EVPriceRuleStackList {
    /// 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);
        // EVPriceRuleStack (1..1024)
        {
            let items = &self.ev_price_rule_stack;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `EVPriceRuleStackType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPriceRuleStack {
    /// `Duration` element, 1..1.
    pub duration: u32,
    /// `EVPriceRule` element, 1..8.
    pub ev_price_rule: Vec<EVPriceRule>,
}

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

impl EVPriceRuleStack {
    /// 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);
        // Duration (1..1)
        {
            let item = &self.duration;
            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);
        }
        // EVPriceRule (1..8)
        {
            let items = &self.ev_price_rule;
            let count = items.len() as u32;
            if count < 1 || count > 8 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 1, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(1, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `EVPriceRuleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EVPriceRule {
    /// `EnergyFee` element, 1..1.
    pub energy_fee: super::common::RationalNumber,
    /// `PowerRangeStart` element, 1..1.
    pub power_range_start: super::common::RationalNumber,
}

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

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

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

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

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

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

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

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

/// `OverstayRuleListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OverstayRuleList {
    /// `OverstayTimeThreshold` element, 0..1.
    pub overstay_time_threshold: Option<u32>,
    /// `OverstayPowerThreshold` element, 0..1.
    pub overstay_power_threshold: Option<super::common::RationalNumber>,
    /// `OverstayRule` element, 1..5.
    pub overstay_rule: Vec<OverstayRule>,
}

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

impl OverstayRuleList {
    /// 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);
        // OverstayTimeThreshold (0..1)
        if let Some(item) = &self.overstay_time_threshold {
            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);
        }
        // OverstayPowerThreshold (0..1)
        if let Some(item) = &self.overstay_power_threshold {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // OverstayRule (1..5)
        {
            let items = &self.overstay_rule;
            let count = items.len() as u32;
            if count < 1 || count > 5 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 2, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(2, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `OverstayRuleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OverstayRule {
    /// `OverstayRuleDescription` element, 0..1.
    pub overstay_rule_description: Option<String>,
    /// `StartTime` element, 1..1.
    pub start_time: u32,
    /// `OverstayFee` element, 1..1.
    pub overstay_fee: super::common::RationalNumber,
    /// `OverstayFeePeriod` element, 1..1.
    pub overstay_fee_period: u32,
}

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

impl OverstayRule {
    /// 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);
        // OverstayRuleDescription (0..1)
        if let Some(item) = &self.overstay_rule_description {
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(123), item, Lengths::max(160))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // StartTime (1..1)
        {
            let item = &self.start_time;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // OverstayFee (1..1)
        {
            let item = &self.overstay_fee;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // OverstayFeePeriod (1..1)
        {
            let item = &self.overstay_fee_period;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

impl Parameter {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Name (1..1)
        {
            let item = &self.name;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(112), item, Lengths::max(80))?;
            w.finish(0, 1);
        }
        // choice of 6 (1..1)
        {
            let item = &self.choice;
            match item {
                ParameterChoice::BoolValue(value) => {
                    w.start_branch(e, 1, 0, 0)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.boolean(*value)?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::ByteValue(value) => {
                    w.start_branch(e, 1, 0, 1)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.restricted(i64::from(*value), -128, 127)?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::ShortValue(value) => {
                    w.start_branch(e, 1, 0, 2)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.int(i64::from(*value))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::IntValue(value) => {
                    w.start_branch(e, 1, 0, 3)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.int(i64::from(*value))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                ParameterChoice::RationalNumber(value) => {
                    w.start_branch(e, 1, 0, 4)?;
                    value.encode_body(e)?;
                }
                ParameterChoice::FiniteString(value) => {
                    w.start_branch(e, 1, 0, 5)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.string(ValueCtx(228), value, Lengths::max(80))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
            }
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl Parameter {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = d.string(ValueCtx(112), Lengths::max(80))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, branch, .. } => {
                    let value = match branch {
                        0 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.boolean()?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::BoolValue(value)
                        }
                        1 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = i8::try_from(d.restricted(-128, 127)?)
                                .map_err(|_| ExiError::ValueOutOfRange)?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::ByteValue(value)
                        }
                        2 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value =
                                i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::ShortValue(value)
                        }
                        3 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value =
                                i32::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::IntValue(value)
                        }
                        4 => {
                            let value = super::common::RationalNumber::decode_body(d)?;
                            ParameterChoice::RationalNumber(value)
                        }
                        5 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.string(ValueCtx(228), Lengths::max(80))?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            ParameterChoice::FiniteString(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            name: f_0.ok_or(ExiError::MissingElement)?,
            choice: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

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

impl PnCAReqAuthorizationMode {
    /// 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 PnCAReqAuthorizationMode {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(92), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // GenChallenge (1..1)
        {
            let item = &self.gen_challenge;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::exact(16))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ContractCertificateChain (1..1)
        {
            let item = &self.contract_certificate_chain;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PnCAReqAuthorizationMode {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = d.string(ValueCtx(92), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::exact(16))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = ContractCertificateChain::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            gen_challenge: f_1.ok_or(ExiError::MissingElement)?,
            contract_certificate_chain: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PnC_ASResAuthorizationModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PnCASResAuthorizationMode {
    /// `GenChallenge` element, 1..1.
    pub gen_challenge: Vec<u8>,
    /// `SupportedProviders` element, 0..1.
    pub supported_providers: Option<SupportedProvidersList>,
}

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

impl PnCASResAuthorizationMode {
    /// 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);
        // GenChallenge (1..1)
        {
            let item = &self.gen_challenge;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::exact(16))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // SupportedProviders (0..1)
        if let Some(item) = &self.supported_providers {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PowerDeliveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerDeliveryReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVProcessing` element, 1..1.
    pub ev_processing: super::common::Processing,
    /// `ChargeProgress` element, 1..1.
    pub charge_progress: ChargeProgress,
    /// `EVPowerProfile` element, 0..1.
    pub ev_power_profile: Option<EVPowerProfile>,
    /// `BPT_ChannelSelection` element, 0..1.
    pub bpt_channel_selection: Option<ChannelSelection>,
}

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

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

impl PowerDeliveryReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = super::common::Processing::from_index(
                        d.nbit(super::common::Processing::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ChargeProgress::from_index(d.nbit(ChargeProgress::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = EVPowerProfile::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = ChannelSelection::from_index(d.nbit(ChannelSelection::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)?,
            ev_processing: f_1.ok_or(ExiError::MissingElement)?,
            charge_progress: f_2.ok_or(ExiError::MissingElement)?,
            ev_power_profile: f_3,
            bpt_channel_selection: f_4,
        })
    }
}

/// `PowerDeliveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerDeliveryRes {
    /// `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>,
}

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

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

impl PowerDeliveryRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        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::EVSEStatus::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_status: f_2,
        })
    }
}

/// `PowerScheduleEntryListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerScheduleEntryList {
    /// `PowerScheduleEntry` element, 1..1024.
    pub power_schedule_entry: Vec<PowerScheduleEntry>,
}

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

impl PowerScheduleEntryList {
    /// 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);
        // PowerScheduleEntry (1..1024)
        {
            let items = &self.power_schedule_entry;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PowerScheduleEntryType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerScheduleEntry {
    /// `Duration` element, 1..1.
    pub duration: u32,
    /// `Power` element, 1..1.
    pub power: super::common::RationalNumber,
    /// `Power_L2` element, 0..1.
    pub power_l2: Option<super::common::RationalNumber>,
    /// `Power_L3` element, 0..1.
    pub power_l3: Option<super::common::RationalNumber>,
}

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

impl PowerScheduleEntry {
    /// 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);
        // Duration (1..1)
        {
            let item = &self.duration;
            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);
        }
        // Power (1..1)
        {
            let item = &self.power;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // Power_L2 (0..1)
        if let Some(item) = &self.power_l2 {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // Power_L3 (0..1)
        if let Some(item) = &self.power_l3 {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PowerScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PowerSchedule {
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `AvailableEnergy` element, 0..1.
    pub available_energy: Option<super::common::RationalNumber>,
    /// `PowerTolerance` element, 0..1.
    pub power_tolerance: Option<super::common::RationalNumber>,
    /// `PowerScheduleEntries` element, 1..1.
    pub power_schedule_entries: PowerScheduleEntryList,
}

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

impl PowerSchedule {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // AvailableEnergy (0..1)
        if let Some(item) = &self.available_energy {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // PowerTolerance (0..1)
        if let Some(item) = &self.power_tolerance {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // PowerScheduleEntries (1..1)
        {
            let item = &self.power_schedule_entries;
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PriceLevelScheduleEntryListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceLevelScheduleEntryList {
    /// `PriceLevelScheduleEntry` element, 1..1024.
    pub price_level_schedule_entry: Vec<PriceLevelScheduleEntry>,
}

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

impl PriceLevelScheduleEntryList {
    /// 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);
        // PriceLevelScheduleEntry (1..1024)
        {
            let items = &self.price_level_schedule_entry;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PriceLevelScheduleEntryType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceLevelScheduleEntry {
    /// `Duration` element, 1..1.
    pub duration: u32,
    /// `PriceLevel` element, 1..1.
    pub price_level: u8,
}

impl PriceLevelScheduleEntry {
    /// 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 PriceLevelScheduleEntry {
    /// 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);
        // Duration (1..1)
        {
            let item = &self.duration;
            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);
        }
        // PriceLevel (1..1)
        {
            let item = &self.price_level;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PriceLevelScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceLevelSchedule {
    /// `Id` attribute, 0..1.
    pub id: Option<String>,
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `PriceScheduleID` element, 1..1.
    pub price_schedule_id: u32,
    /// `PriceScheduleDescription` element, 0..1.
    pub price_schedule_description: Option<String>,
    /// `NumberOfPriceLevels` element, 1..1.
    pub number_of_price_levels: u8,
    /// `PriceLevelScheduleEntries` element, 1..1.
    pub price_level_schedule_entries: PriceLevelScheduleEntryList,
}

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

impl PriceLevelSchedule {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Id (0..1)
        if let Some(item) = &self.id {
            w.start(e, 0, 0)?;
            e.string(ValueCtx(92), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PriceScheduleID (1..1)
        {
            let item = &self.price_schedule_id;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // PriceScheduleDescription (0..1)
        if let Some(item) = &self.price_schedule_description {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(153), item, Lengths::max(160))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // NumberOfPriceLevels (1..1)
        {
            let item = &self.number_of_price_levels;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // PriceLevelScheduleEntries (1..1)
        {
            let item = &self.price_level_schedule_entries;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PriceLevelSchedule {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = d.string(ValueCtx(92), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u64::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(153), Lengths::max(160))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = PriceLevelScheduleEntryList::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0,
            time_anchor: f_1.ok_or(ExiError::MissingElement)?,
            price_schedule_id: f_2.ok_or(ExiError::MissingElement)?,
            price_schedule_description: f_3,
            number_of_price_levels: f_4.ok_or(ExiError::MissingElement)?,
            price_level_schedule_entries: f_5.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PriceRuleStackListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceRuleStackList {
    /// `PriceRuleStack` element, 1..1024.
    pub price_rule_stack: Vec<PriceRuleStack>,
}

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

impl PriceRuleStackList {
    /// 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);
        // PriceRuleStack (1..1024)
        {
            let items = &self.price_rule_stack;
            let count = items.len() as u32;
            if count < 1 || count > 1024 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PriceRuleStackType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceRuleStack {
    /// `Duration` element, 1..1.
    pub duration: u32,
    /// `PriceRule` element, 1..8.
    pub price_rule: Vec<PriceRule>,
}

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

impl PriceRuleStack {
    /// 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);
        // Duration (1..1)
        {
            let item = &self.duration;
            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);
        }
        // PriceRule (1..8)
        {
            let items = &self.price_rule;
            let count = items.len() as u32;
            if count < 1 || count > 8 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 1, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(1, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `PriceRuleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceRule {
    /// `EnergyFee` element, 1..1.
    pub energy_fee: super::common::RationalNumber,
    /// `ParkingFee` element, 0..1.
    pub parking_fee: Option<super::common::RationalNumber>,
    /// `ParkingFeePeriod` element, 0..1.
    pub parking_fee_period: Option<u32>,
    /// `CarbonDioxideEmission` element, 0..1.
    pub carbon_dioxide_emission: Option<u16>,
    /// `RenewableGenerationPercentage` element, 0..1.
    pub renewable_generation_percentage: Option<u8>,
    /// `PowerRangeStart` element, 1..1.
    pub power_range_start: super::common::RationalNumber,
}

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

impl PriceRule {
    /// 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);
        // EnergyFee (1..1)
        {
            let item = &self.energy_fee;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ParkingFee (0..1)
        if let Some(item) = &self.parking_fee {
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ParkingFeePeriod (0..1)
        if let Some(item) = &self.parking_fee_period {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // CarbonDioxideEmission (0..1)
        if let Some(item) = &self.carbon_dioxide_emission {
            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);
        }
        // RenewableGenerationPercentage (0..1)
        if let Some(item) = &self.renewable_generation_percentage {
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 0, 255)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // PowerRangeStart (1..1)
        {
            let item = &self.power_range_start;
            w.start(e, 5, 0)?;
            item.encode_body(e)?;
            w.finish(5, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl PriceRule {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = 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, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u32::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = u8::try_from(d.restricted(0, 255)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_5 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            energy_fee: f_0.ok_or(ExiError::MissingElement)?,
            parking_fee: f_1,
            parking_fee_period: f_2,
            carbon_dioxide_emission: f_3,
            renewable_generation_percentage: f_4,
            power_range_start: f_5.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `PriceScheduleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PriceSchedule {
    /// `TimeAnchor` element, 1..1.
    pub time_anchor: u64,
    /// `PriceScheduleID` element, 1..1.
    pub price_schedule_id: u32,
    /// `PriceScheduleDescription` element, 0..1.
    pub price_schedule_description: Option<String>,
}

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

impl PriceSchedule {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TimeAnchor (1..1)
        {
            let item = &self.time_anchor;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // PriceScheduleID (1..1)
        {
            let item = &self.price_schedule_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // PriceScheduleDescription (0..1)
        if let Some(item) = &self.price_schedule_description {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(153), item, Lengths::max(160))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// The `choice of 2` alternatives of [`ScheduleExchangeReq`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ScheduleExchangeReqChoice {
    /// `Dynamic_SEReqControlMode`
    DynamicSEReqControlMode(DynamicSEReqControlMode),
    /// `Scheduled_SEReqControlMode`
    ScheduledSEReqControlMode(ScheduledSEReqControlMode),
}

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

/// `ScheduleExchangeReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduleExchangeReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `MaximumSupportingPoints` element, 1..1.
    pub maximum_supporting_points: u16,
    /// `choice of 2` element, 1..1.
    pub choice: ScheduleExchangeReqChoice,
}

impl ScheduleExchangeReq {
    /// 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 ScheduleExchangeReq {
    /// 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);
        }
        // MaximumSupportingPoints (1..1)
        {
            let item = &self.maximum_supporting_points;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.restricted(i64::from(*item), 12, 1024)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                ScheduleExchangeReqChoice::DynamicSEReqControlMode(value) => {
                    w.start_branch(e, 2, 0, 0)?;
                    value.encode_body(e)?;
                }
                ScheduleExchangeReqChoice::ScheduledSEReqControlMode(value) => {
                    w.start_branch(e, 2, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ScheduleExchangeReq {
    /// 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 = u16::try_from(d.restricted(12, 1024)?)
                        .map_err(|_| ExiError::ValueOutOfRange)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = DynamicSEReqControlMode::decode_body(d)?;
                            ScheduleExchangeReqChoice::DynamicSEReqControlMode(value)
                        }
                        1 => {
                            let value = ScheduledSEReqControlMode::decode_body(d)?;
                            ScheduleExchangeReqChoice::ScheduledSEReqControlMode(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)?,
            maximum_supporting_points: f_1.ok_or(ExiError::MissingElement)?,
            choice: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`ScheduleExchangeRes`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ScheduleExchangeResChoice {
    /// `Dynamic_SEResControlMode`
    DynamicSEResControlMode(DynamicSEResControlMode),
    /// `Scheduled_SEResControlMode`
    ScheduledSEResControlMode(ScheduledSEResControlMode),
}

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

/// `ScheduleExchangeResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduleExchangeRes {
    /// `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,
    /// `GoToPause` element, 0..1.
    pub go_to_pause: Option<bool>,
    /// `choice of 2` element, 1..1.
    pub choice: ScheduleExchangeResChoice,
}

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

impl ScheduleExchangeRes {
    /// 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);
        }
        // GoToPause (0..1)
        if let Some(item) = &self.go_to_pause {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                ScheduleExchangeResChoice::DynamicSEResControlMode(value) => {
                    w.start_branch(e, 4, 0, 0)?;
                    value.encode_body(e)?;
                }
                ScheduleExchangeResChoice::ScheduledSEResControlMode(value) => {
                    w.start_branch(e, 4, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ScheduleExchangeRes {
    /// 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 = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = DynamicSEResControlMode::decode_body(d)?;
                            ScheduleExchangeResChoice::DynamicSEResControlMode(value)
                        }
                        1 => {
                            let value = ScheduledSEResControlMode::decode_body(d)?;
                            ScheduleExchangeResChoice::ScheduledSEResControlMode(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)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            evse_processing: f_2.ok_or(ExiError::MissingElement)?,
            go_to_pause: f_3,
            choice: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ScheduleTupleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduleTuple {
    /// `ScheduleTupleID` element, 1..1.
    pub schedule_tuple_id: u32,
    /// `ChargingSchedule` element, 1..1.
    pub charging_schedule: ChargingSchedule,
    /// `DischargingSchedule` element, 0..1.
    pub discharging_schedule: Option<ChargingSchedule>,
}

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

impl ScheduleTuple {
    /// 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);
        // ScheduleTupleID (1..1)
        {
            let item = &self.schedule_tuple_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // ChargingSchedule (1..1)
        {
            let item = &self.charging_schedule;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // DischargingSchedule (0..1)
        if let Some(item) = &self.discharging_schedule {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `Scheduled_EVPPTControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledEVPPTControlMode {
    /// `SelectedScheduleTupleID` element, 1..1.
    pub selected_schedule_tuple_id: u32,
    /// `PowerToleranceAcceptance` element, 0..1.
    pub power_tolerance_acceptance: Option<PowerToleranceAcceptance>,
}

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

impl ScheduledEVPPTControlMode {
    /// 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);
        // SelectedScheduleTupleID (1..1)
        {
            let item = &self.selected_schedule_tuple_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // PowerToleranceAcceptance (0..1)
        if let Some(item) = &self.power_tolerance_acceptance {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), PowerToleranceAcceptance::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `Scheduled_SEReqControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledSEReqControlMode {
    /// `DepartureTime` element, 0..1.
    pub departure_time: Option<u32>,
    /// `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>,
    /// `EVEnergyOffer` element, 0..1.
    pub ev_energy_offer: Option<EVEnergyOffer>,
}

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

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

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

/// `Scheduled_SEResControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledSEResControlMode {
    /// `ScheduleTuple` element, 1..3.
    pub schedule_tuple: Vec<ScheduleTuple>,
}

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

impl ScheduledSEResControlMode {
    /// 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);
        // ScheduleTuple (1..3)
        {
            let items = &self.schedule_tuple;
            let count = items.len() as u32;
            if count < 1 || count > 3 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `Scheduled_SMDTControlModeType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ScheduledSMDTControlMode {
    /// `SelectedScheduleTupleID` element, 1..1.
    pub selected_schedule_tuple_id: u32,
}

impl ScheduledSMDTControlMode {
    /// 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 ScheduledSMDTControlMode {
    /// 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);
        // SelectedScheduleTupleID (1..1)
        {
            let item = &self.selected_schedule_tuple_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl ServiceDetailRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        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::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 = u16::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = ServiceParameterList::decode_body(d)?;
                    f_3 = 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)?,
            service_id: f_2.ok_or(ExiError::MissingElement)?,
            service_parameter_list: f_3.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `ServiceDiscoveryReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceDiscoveryReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `SupportedServiceIDs` element, 0..1.
    pub supported_service_i_ds: Option<ServiceIDList>,
}

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

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

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

/// `ServiceDiscoveryResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceDiscoveryRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `ServiceRenegotiationSupported` element, 1..1.
    pub service_renegotiation_supported: bool,
    /// `EnergyTransferServiceList` element, 1..1.
    pub energy_transfer_service_list: ServiceList,
    /// `VASList` element, 0..1.
    pub vas_list: Option<ServiceList>,
}

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

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

impl ServiceDiscoveryRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        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 = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = ServiceList::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    let value = ServiceList::decode_body(d)?;
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            service_renegotiation_supported: f_2.ok_or(ExiError::MissingElement)?,
            energy_transfer_service_list: f_3.ok_or(ExiError::MissingElement)?,
            vas_list: f_4,
        })
    }
}

/// `ServiceIDListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceIDList {
    /// `ServiceID` element, 1..16.
    pub service_id: Vec<u16>,
}

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

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

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

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

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

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

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

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

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

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

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

/// `ServiceSelectionReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceSelectionReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `SelectedEnergyTransferService` element, 1..1.
    pub selected_energy_transfer_service: SelectedService,
    /// `SelectedVASList` element, 0..1.
    pub selected_vas_list: Option<SelectedServiceList>,
}

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

impl ServiceSelectionReq {
    /// 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);
        }
        // SelectedEnergyTransferService (1..1)
        {
            let item = &self.selected_energy_transfer_service;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // SelectedVASList (0..1)
        if let Some(item) = &self.selected_vas_list {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl ServiceSelectionReq {
    /// 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, .. } => {
                    let value = SelectedService::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = SelectedServiceList::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            selected_energy_transfer_service: f_1.ok_or(ExiError::MissingElement)?,
            selected_vas_list: f_2,
        })
    }
}

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

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

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

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

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

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

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

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

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

impl SessionSetupReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        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 = d.string(ValueCtx(51), Lengths::max(255))?;
                    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)?,
            evcc_id: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `SessionSetupResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SessionSetupRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSEID` element, 1..1.
    pub evse_id: String,
}

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

impl SessionSetupRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    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 = d.string(ValueCtx(72), Lengths::max(255))?;
                    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_id: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `SessionStopReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SessionStopReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ChargingSession` element, 1..1.
    pub charging_session: ChargingSession,
    /// `EVTerminationCode` element, 0..1.
    pub ev_termination_code: Option<String>,
    /// `EVTerminationExplanation` element, 0..1.
    pub ev_termination_explanation: Option<String>,
}

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

impl SessionStopReq {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Header (1..1)
        {
            let item = &self.header;
            w.start(e, 0, 0)?;
            item.encode_body(e)?;
            w.finish(0, 1);
        }
        // ChargingSession (1..1)
        {
            let item = &self.charging_session;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ChargingSession::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // EVTerminationCode (0..1)
        if let Some(item) = &self.ev_termination_code {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(79), item, Lengths::max(80))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // EVTerminationExplanation (0..1)
        if let Some(item) = &self.ev_termination_explanation {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(80), item, Lengths::max(160))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SessionStopReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        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 = ChargingSession::from_index(d.nbit(ChargingSession::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(79), Lengths::max(80))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.string(ValueCtx(80), Lengths::max(160))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            charging_session: f_1.ok_or(ExiError::MissingElement)?,
            ev_termination_code: f_2,
            ev_termination_explanation: f_3,
        })
    }
}

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

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

impl SessionStopRes {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        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::ResponseCode::from_index(
                        d.nbit(super::common::ResponseCode::WIDTH)?,
                    )?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
        })
    }
}

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

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

impl SignedCertificateChain {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(92), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // Certificate (1..1)
        {
            let item = &self.certificate;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::max(1600))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // SubCertificates (0..1)
        if let Some(item) = &self.sub_certificates {
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SignedCertificateChain {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = d.string(ValueCtx(92), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::max(1600))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = SubCertificates::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            certificate: f_1.ok_or(ExiError::MissingElement)?,
            sub_certificates: f_2,
        })
    }
}

/// The `choice of 3` alternatives of [`SignedInstallationData`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SignedInstallationDataChoice {
    /// `SECP521_EncryptedPrivateKey`
    SECP521EncryptedPrivateKey(Vec<u8>),
    /// `X448_EncryptedPrivateKey`
    X448EncryptedPrivateKey(Vec<u8>),
    /// `TPM_EncryptedPrivateKey`
    TPMEncryptedPrivateKey(Vec<u8>),
}

impl SignedInstallationDataChoice {
    /// The element name of the alternative taken.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::SECP521EncryptedPrivateKey(_) => "SECP521_EncryptedPrivateKey",
            Self::X448EncryptedPrivateKey(_) => "X448_EncryptedPrivateKey",
            Self::TPMEncryptedPrivateKey(_) => "TPM_EncryptedPrivateKey",
        }
    }
}

/// `SignedInstallationDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignedInstallationData {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `ContractCertificateChain` element, 1..1.
    pub contract_certificate_chain: ContractCertificateChain,
    /// `ECDHCurve` element, 1..1.
    pub ec_dh_curve: EcdhCurve,
    /// `DHPublicKey` element, 1..1.
    pub dh_public_key: Vec<u8>,
    /// `choice of 3` element, 1..1.
    pub choice: SignedInstallationDataChoice,
}

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

impl SignedInstallationData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(92), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // ContractCertificateChain (1..1)
        {
            let item = &self.contract_certificate_chain;
            w.start(e, 1, 0)?;
            item.encode_body(e)?;
            w.finish(1, 1);
        }
        // ECDHCurve (1..1)
        {
            let item = &self.ec_dh_curve;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EcdhCurve::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // DHPublicKey (1..1)
        {
            let item = &self.dh_public_key;
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::exact(133))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // choice of 3 (1..1)
        {
            let item = &self.choice;
            match item {
                SignedInstallationDataChoice::SECP521EncryptedPrivateKey(value) => {
                    w.start_branch(e, 4, 0, 0)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.binary(value, Lengths::exact(94))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                SignedInstallationDataChoice::X448EncryptedPrivateKey(value) => {
                    w.start_branch(e, 4, 0, 1)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.binary(value, Lengths::exact(84))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
                SignedInstallationDataChoice::TPMEncryptedPrivateKey(value) => {
                    w.start_branch(e, 4, 0, 2)?;
                    e.event(0, SIMPLE_WIDTH)?; // CH
                    e.binary(value, Lengths::exact(206))?;
                    e.event(0, SIMPLE_WIDTH)?; // EE
                }
            }
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SignedInstallationData {
    /// 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 = d.string(ValueCtx(92), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    let value = ContractCertificateChain::decode_body(d)?;
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = EcdhCurve::from_index(d.nbit(EcdhCurve::WIDTH)?)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::exact(133))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, branch, .. } => {
                    let value = match branch {
                        0 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.binary(Lengths::exact(94))?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            SignedInstallationDataChoice::SECP521EncryptedPrivateKey(value)
                        }
                        1 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.binary(Lengths::exact(84))?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            SignedInstallationDataChoice::X448EncryptedPrivateKey(value)
                        }
                        2 => {
                            d.expect_event(0, SIMPLE_WIDTH)?; // CH
                            let value = d.binary(Lengths::exact(206))?;
                            d.expect_event(0, SIMPLE_WIDTH)?; // EE
                            SignedInstallationDataChoice::TPMEncryptedPrivateKey(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            contract_certificate_chain: f_1.ok_or(ExiError::MissingElement)?,
            ec_dh_curve: f_2.ok_or(ExiError::MissingElement)?,
            dh_public_key: f_3.ok_or(ExiError::MissingElement)?,
            choice: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// The `choice of 2` alternatives of [`SignedMeteringData`].
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SignedMeteringDataChoice {
    /// `Dynamic_SMDTControlMode`
    DynamicSMDTControlMode(DynamicSMDTControlMode),
    /// `Scheduled_SMDTControlMode`
    ScheduledSMDTControlMode(ScheduledSMDTControlMode),
}

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

/// `SignedMeteringDataType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SignedMeteringData {
    /// `Id` attribute, 1..1.
    pub id: String,
    /// `SessionID` element, 1..1.
    pub session_id: Vec<u8>,
    /// `MeterInfo` element, 1..1.
    pub meter_info: super::common::MeterInfo,
    /// `Receipt` element, 0..1.
    pub receipt: Option<super::common::Receipt>,
    /// `choice of 2` element, 1..1.
    pub choice: SignedMeteringDataChoice,
}

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

impl SignedMeteringData {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // Id (1..1)
        {
            let item = &self.id;
            w.start(e, 0, 0)?;
            e.string(ValueCtx(92), item, Lengths::max(65536))?;
            w.finish(0, 1);
        }
        // SessionID (1..1)
        {
            let item = &self.session_id;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.binary(item, Lengths::exact(8))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // MeterInfo (1..1)
        {
            let item = &self.meter_info;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // Receipt (0..1)
        if let Some(item) = &self.receipt {
            w.start(e, 3, 0)?;
            item.encode_body(e)?;
            w.finish(3, 1);
        }
        // choice of 2 (1..1)
        {
            let item = &self.choice;
            match item {
                SignedMeteringDataChoice::DynamicSMDTControlMode(value) => {
                    w.start_branch(e, 4, 0, 0)?;
                    value.encode_body(e)?;
                }
                SignedMeteringDataChoice::ScheduledSMDTControlMode(value) => {
                    w.start_branch(e, 4, 0, 1)?;
                    value.encode_body(e)?;
                }
            }
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl SignedMeteringData {
    /// 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 = d.string(ValueCtx(92), Lengths::max(65536))?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.binary(Lengths::exact(8))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::MeterInfo::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    let value = super::common::Receipt::decode_body(d)?;
                    f_3 = Some(value);
                }
                Step::Item { index: 4, branch, .. } => {
                    let value = match branch {
                        0 => {
                            let value = DynamicSMDTControlMode::decode_body(d)?;
                            SignedMeteringDataChoice::DynamicSMDTControlMode(value)
                        }
                        1 => {
                            let value = ScheduledSMDTControlMode::decode_body(d)?;
                            SignedMeteringDataChoice::ScheduledSMDTControlMode(value)
                        }
                        _ => return Err(ExiError::UnknownEventCode),
                    };
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            id: f_0.ok_or(ExiError::MissingElement)?,
            session_id: f_1.ok_or(ExiError::MissingElement)?,
            meter_info: f_2.ok_or(ExiError::MissingElement)?,
            receipt: f_3,
            choice: f_4.ok_or(ExiError::MissingElement)?,
        })
    }
}

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

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

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

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

/// `SupportedProvidersListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SupportedProvidersList {
    /// `ProviderID` element, 1..128.
    pub provider_id: Vec<String>,
}

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

impl SupportedProvidersList {
    /// 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);
        // ProviderID (1..128)
        {
            let items = &self.provider_id;
            let count = items.len() as u32;
            if count < 1 || count > 128 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                e.event(0, SIMPLE_WIDTH)?; // CH
                e.string(ValueCtx(156), item, Lengths::max(80))?;
                e.event(0, SIMPLE_WIDTH)?; // EE
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `TargetPositionType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TargetPosition {
    /// `TargetOffsetX` element, 1..1.
    pub target_offset_x: u16,
    /// `TargetOffsetY` element, 1..1.
    pub target_offset_y: u16,
}

impl TargetPosition {
    /// 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 TargetPosition {
    /// 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);
        // TargetOffsetX (1..1)
        {
            let item = &self.target_offset_x;
            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);
        }
        // TargetOffsetY (1..1)
        {
            let item = &self.target_offset_y;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `TaxRuleListType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TaxRuleList {
    /// `TaxRule` element, 1..10.
    pub tax_rule: Vec<TaxRule>,
}

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

impl TaxRuleList {
    /// 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);
        // TaxRule (1..10)
        {
            let items = &self.tax_rule;
            let count = items.len() as u32;
            if count < 1 || count > 10 {
                return Err(ExiError::ValueOutOfRange);
            }
            for (c, item) in items.iter().enumerate() {
                w.start(e, 0, c as u32)?;
                item.encode_body(e)?;
            }
            if count > 0 {
                w.finish(0, count);
            }
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

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

/// `TaxRuleType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TaxRule {
    /// `TaxRuleID` element, 1..1.
    pub tax_rule_id: u32,
    /// `TaxRuleName` element, 0..1.
    pub tax_rule_name: Option<String>,
    /// `TaxRate` element, 1..1.
    pub tax_rate: super::common::RationalNumber,
    /// `TaxIncludedInPrice` element, 0..1.
    pub tax_included_in_price: Option<bool>,
    /// `AppliesToEnergyFee` element, 1..1.
    pub applies_to_energy_fee: bool,
    /// `AppliesToParkingFee` element, 1..1.
    pub applies_to_parking_fee: bool,
    /// `AppliesToOverstayFee` element, 1..1.
    pub applies_to_overstay_fee: bool,
    /// `AppliesMinimumMaximumCost` element, 1..1.
    pub applies_minimum_maximum_cost: bool,
}

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

impl TaxRule {
    /// Writes this element's content and its end event.
    ///
    /// The parent writes the start event; this writes everything
    /// inside it, so the two compose without either knowing the
    /// other's grammar.
    pub fn encode_body(&self, e: &mut Encoder<'_>) -> ExiResult<()> {
        e.enter()?;
        let mut w = SeqWriter::new(Self::SHAPE);
        // TaxRuleID (1..1)
        {
            let item = &self.tax_rule_id;
            w.start(e, 0, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(0, 1);
        }
        // TaxRuleName (0..1)
        if let Some(item) = &self.tax_rule_name {
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.string(ValueCtx(209), item, Lengths::max(80))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // TaxRate (1..1)
        {
            let item = &self.tax_rate;
            w.start(e, 2, 0)?;
            item.encode_body(e)?;
            w.finish(2, 1);
        }
        // TaxIncludedInPrice (0..1)
        if let Some(item) = &self.tax_included_in_price {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // AppliesToEnergyFee (1..1)
        {
            let item = &self.applies_to_energy_fee;
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        // AppliesToParkingFee (1..1)
        {
            let item = &self.applies_to_parking_fee;
            w.start(e, 5, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(5, 1);
        }
        // AppliesToOverstayFee (1..1)
        {
            let item = &self.applies_to_overstay_fee;
            w.start(e, 6, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.boolean(*item)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(6, 1);
        }
        // AppliesMinimumMaximumCost (1..1)
        {
            let item = &self.applies_minimum_maximum_cost;
            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 TaxRule {
    /// 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 = d.string(ValueCtx(209), Lengths::max(80))?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_1 = Some(value);
                }
                Step::Item { index: 2, .. } => {
                    let value = super::common::RationalNumber::decode_body(d)?;
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = 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 = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { index: 5, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_5 = Some(value);
                }
                Step::Item { index: 6, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = d.boolean()?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_6 = Some(value);
                }
                Step::Item { index: 7, .. } => {
                    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 {
            tax_rule_id: f_0.ok_or(ExiError::MissingElement)?,
            tax_rule_name: f_1,
            tax_rate: f_2.ok_or(ExiError::MissingElement)?,
            tax_included_in_price: f_3,
            applies_to_energy_fee: f_4.ok_or(ExiError::MissingElement)?,
            applies_to_parking_fee: f_5.ok_or(ExiError::MissingElement)?,
            applies_to_overstay_fee: f_6.ok_or(ExiError::MissingElement)?,
            applies_minimum_maximum_cost: f_7.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `VehicleCheckInReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VehicleCheckInReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVCheckInStatus` element, 1..1.
    pub ev_check_in_status: EvCheckInStatus,
    /// `ParkingMethod` element, 1..1.
    pub parking_method: ParkingMethod,
    /// `VehicleFrame` element, 0..1.
    pub vehicle_frame: Option<i16>,
    /// `DeviceOffset` element, 0..1.
    pub device_offset: Option<i16>,
    /// `VehicleTravel` element, 0..1.
    pub vehicle_travel: Option<i16>,
}

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

impl VehicleCheckInReq {
    /// 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);
        }
        // EVCheckInStatus (1..1)
        {
            let item = &self.ev_check_in_status;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EvCheckInStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // ParkingMethod (1..1)
        {
            let item = &self.parking_method;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), ParkingMethod::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // VehicleFrame (0..1)
        if let Some(item) = &self.vehicle_frame {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // DeviceOffset (0..1)
        if let Some(item) = &self.device_offset {
            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);
        }
        // VehicleTravel (0..1)
        if let Some(item) = &self.vehicle_travel {
            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);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl VehicleCheckInReq {
    /// Reads this element's content, up to and including its end
    /// event. The parent has already read the start event.
    pub fn decode_body(d: &mut Decoder<'_>) -> ExiResult<Self> {
        d.enter()?;
        let mut r = SeqReader::new(Self::SHAPE);
        let mut f_0 = None;
        let mut f_1 = None;
        let mut f_2 = None;
        let mut f_3 = None;
        let mut f_4 = None;
        let mut f_5 = None;
        loop {
            match r.next(d)? {
                Step::End => break,
                Step::Item { index: 0, .. } => {
                    let value = super::common::MessageHeader::decode_body(d)?;
                    f_0 = Some(value);
                }
                Step::Item { index: 1, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = EvCheckInStatus::from_index(d.nbit(EvCheckInStatus::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 = ParkingMethod::from_index(d.nbit(ParkingMethod::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 = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = 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 { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_check_in_status: f_1.ok_or(ExiError::MissingElement)?,
            parking_method: f_2.ok_or(ExiError::MissingElement)?,
            vehicle_frame: f_3,
            device_offset: f_4,
            vehicle_travel: f_5,
        })
    }
}

/// `VehicleCheckInResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VehicleCheckInRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `ParkingSpace` element, 0..1.
    pub parking_space: Option<i16>,
    /// `DeviceLocation` element, 0..1.
    pub device_location: Option<i16>,
    /// `TargetDistance` element, 0..1.
    pub target_distance: Option<i16>,
}

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

impl VehicleCheckInRes {
    /// 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);
        }
        // ParkingSpace (0..1)
        if let Some(item) = &self.parking_space {
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        // DeviceLocation (0..1)
        if let Some(item) = &self.device_location {
            w.start(e, 3, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(3, 1);
        }
        // TargetDistance (0..1)
        if let Some(item) = &self.target_distance {
            w.start(e, 4, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.int(i64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(4, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl VehicleCheckInRes {
    /// 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 = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { index: 3, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_3 = Some(value);
                }
                Step::Item { index: 4, .. } => {
                    d.expect_event(0, SIMPLE_WIDTH)?; // CH
                    let value = i16::try_from(d.int()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_4 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            response_code: f_1.ok_or(ExiError::MissingElement)?,
            parking_space: f_2,
            device_location: f_3,
            target_distance: f_4,
        })
    }
}

/// `VehicleCheckOutReqType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VehicleCheckOutReq {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `EVCheckOutStatus` element, 1..1.
    pub ev_check_out_status: EvCheckOutStatus,
    /// `CheckOutTime` element, 1..1.
    pub check_out_time: u64,
}

impl VehicleCheckOutReq {
    /// 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 VehicleCheckOutReq {
    /// 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);
        }
        // EVCheckOutStatus (1..1)
        {
            let item = &self.ev_check_out_status;
            w.start(e, 1, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.nbit(item.as_index(), EvCheckOutStatus::WIDTH)?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(1, 1);
        }
        // CheckOutTime (1..1)
        {
            let item = &self.check_out_time;
            w.start(e, 2, 0)?;
            e.event(0, SIMPLE_WIDTH)?; // CH
            e.uint(u64::from(*item))?;
            e.event(0, SIMPLE_WIDTH)?; // EE
            w.finish(2, 1);
        }
        w.end(e)?;
        e.leave();
        Ok(())
    }
}

impl VehicleCheckOutReq {
    /// 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 = EvCheckOutStatus::from_index(d.nbit(EvCheckOutStatus::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 = u64::try_from(d.uint()?).map_err(|_| ExiError::IntegerOverflow)?;
                    d.expect_event(0, SIMPLE_WIDTH)?; // EE
                    f_2 = Some(value);
                }
                Step::Item { .. } => return Err(ExiError::UnknownEventCode),
            }
        }
        d.leave();
        Ok(Self {
            header: f_0.ok_or(ExiError::MissingElement)?,
            ev_check_out_status: f_1.ok_or(ExiError::MissingElement)?,
            check_out_time: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

/// `VehicleCheckOutResType`.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VehicleCheckOutRes {
    /// `Header` element, 1..1.
    pub header: super::common::MessageHeader,
    /// `ResponseCode` element, 1..1.
    pub response_code: super::common::ResponseCode,
    /// `EVSECheckOutStatus` element, 1..1.
    pub evse_check_out_status: EvseCheckOutStatus,
}

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

impl VehicleCheckOutRes {
    /// 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 = EvseCheckOutStatus::from_index(d.nbit(EvseCheckOutStatus::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_check_out_status: f_2.ok_or(ExiError::MissingElement)?,
        })
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `evCheckInStatusType`.
///
/// 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 EvCheckInStatus {
    /// `CheckIn`
    CheckIn = 0,
    /// `Processing`
    Processing = 1,
    /// `Completed`
    Completed = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::CheckIn, Self::Processing, Self::Completed];

    /// 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::CheckIn,
            1 => Self::Processing,
            2 => Self::Completed,
            _ => 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::CheckIn => "CheckIn",
            Self::Processing => "Processing",
            Self::Completed => "Completed",
        }
    }
}

/// `evCheckOutStatusType`.
///
/// 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 EvCheckOutStatus {
    /// `CheckOut`
    CheckOut = 0,
    /// `Processing`
    Processing = 1,
    /// `Completed`
    Completed = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::CheckOut, Self::Processing, Self::Completed];

    /// 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::CheckOut,
            1 => Self::Processing,
            2 => Self::Completed,
            _ => 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::CheckOut => "CheckOut",
            Self::Processing => "Processing",
            Self::Completed => "Completed",
        }
    }
}

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

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

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

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

/// `parkingMethodType`.
///
/// 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 ParkingMethod {
    /// `AutoParking`
    AutoParking = 0,
    /// `MVGuideManual`
    MVGuideManual = 1,
    /// `Manual`
    Manual = 2,
}

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

    /// Every value, in EXI index order.
    pub const ALL: [Self; 3] = [Self::AutoParking, Self::MVGuideManual, Self::Manual];

    /// 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::AutoParking,
            1 => Self::MVGuideManual,
            2 => Self::Manual,
            _ => 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::AutoParking => "AutoParking",
            Self::MVGuideManual => "MVGuideManual",
            Self::Manual => "Manual",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl crate::exi::ExiDocument for VehicleCheckOutRes {
    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 {
    /// `AuthorizationReq`
    AuthorizationReq(AuthorizationReq),
    /// `AuthorizationRes`
    AuthorizationRes(AuthorizationRes),
    /// `AuthorizationSetupReq`
    AuthorizationSetupReq(AuthorizationSetupReq),
    /// `AuthorizationSetupRes`
    AuthorizationSetupRes(AuthorizationSetupRes),
    /// `CertificateInstallationReq`
    CertificateInstallationReq(CertificateInstallationReq),
    /// `CertificateInstallationRes`
    CertificateInstallationRes(CertificateInstallationRes),
    /// `MeteringConfirmationReq`
    MeteringConfirmationReq(MeteringConfirmationReq),
    /// `MeteringConfirmationRes`
    MeteringConfirmationRes(MeteringConfirmationRes),
    /// `PowerDeliveryReq`
    PowerDeliveryReq(PowerDeliveryReq),
    /// `PowerDeliveryRes`
    PowerDeliveryRes(PowerDeliveryRes),
    /// `ScheduleExchangeReq`
    ScheduleExchangeReq(ScheduleExchangeReq),
    /// `ScheduleExchangeRes`
    ScheduleExchangeRes(ScheduleExchangeRes),
    /// `ServiceDetailReq`
    ServiceDetailReq(ServiceDetailReq),
    /// `ServiceDetailRes`
    ServiceDetailRes(ServiceDetailRes),
    /// `ServiceDiscoveryReq`
    ServiceDiscoveryReq(ServiceDiscoveryReq),
    /// `ServiceDiscoveryRes`
    ServiceDiscoveryRes(ServiceDiscoveryRes),
    /// `ServiceSelectionReq`
    ServiceSelectionReq(ServiceSelectionReq),
    /// `ServiceSelectionRes`
    ServiceSelectionRes(ServiceSelectionRes),
    /// `SessionSetupReq`
    SessionSetupReq(SessionSetupReq),
    /// `SessionSetupRes`
    SessionSetupRes(SessionSetupRes),
    /// `SessionStopReq`
    SessionStopReq(SessionStopReq),
    /// `SessionStopRes`
    SessionStopRes(SessionStopRes),
    /// `SignedInstallationData`
    SignedInstallationData(SignedInstallationData),
    /// `SignedMeteringData`
    SignedMeteringData(SignedMeteringData),
    /// `VehicleCheckInReq`
    VehicleCheckInReq(VehicleCheckInReq),
    /// `VehicleCheckInRes`
    VehicleCheckInRes(VehicleCheckInRes),
    /// `VehicleCheckOutReq`
    VehicleCheckOutReq(VehicleCheckOutReq),
    /// `VehicleCheckOutRes`
    VehicleCheckOutRes(VehicleCheckOutRes),
}

impl Document {
    /// The element name of this document.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::AuthorizationReq(_) => "AuthorizationReq",
            Self::AuthorizationRes(_) => "AuthorizationRes",
            Self::AuthorizationSetupReq(_) => "AuthorizationSetupReq",
            Self::AuthorizationSetupRes(_) => "AuthorizationSetupRes",
            Self::CertificateInstallationReq(_) => "CertificateInstallationReq",
            Self::CertificateInstallationRes(_) => "CertificateInstallationRes",
            Self::MeteringConfirmationReq(_) => "MeteringConfirmationReq",
            Self::MeteringConfirmationRes(_) => "MeteringConfirmationRes",
            Self::PowerDeliveryReq(_) => "PowerDeliveryReq",
            Self::PowerDeliveryRes(_) => "PowerDeliveryRes",
            Self::ScheduleExchangeReq(_) => "ScheduleExchangeReq",
            Self::ScheduleExchangeRes(_) => "ScheduleExchangeRes",
            Self::ServiceDetailReq(_) => "ServiceDetailReq",
            Self::ServiceDetailRes(_) => "ServiceDetailRes",
            Self::ServiceDiscoveryReq(_) => "ServiceDiscoveryReq",
            Self::ServiceDiscoveryRes(_) => "ServiceDiscoveryRes",
            Self::ServiceSelectionReq(_) => "ServiceSelectionReq",
            Self::ServiceSelectionRes(_) => "ServiceSelectionRes",
            Self::SessionSetupReq(_) => "SessionSetupReq",
            Self::SessionSetupRes(_) => "SessionSetupRes",
            Self::SessionStopReq(_) => "SessionStopReq",
            Self::SessionStopRes(_) => "SessionStopRes",
            Self::SignedInstallationData(_) => "SignedInstallationData",
            Self::SignedMeteringData(_) => "SignedMeteringData",
            Self::VehicleCheckInReq(_) => "VehicleCheckInReq",
            Self::VehicleCheckInRes(_) => "VehicleCheckInRes",
            Self::VehicleCheckOutReq(_) => "VehicleCheckOutReq",
            Self::VehicleCheckOutRes(_) => "VehicleCheckOutRes",
        }
    }

    /// The document event code of this message.
    #[must_use]
    pub const fn code(&self) -> u64 {
        match self {
            Self::AuthorizationReq(_) => 0,
            Self::AuthorizationRes(_) => 1,
            Self::AuthorizationSetupReq(_) => 2,
            Self::AuthorizationSetupRes(_) => 3,
            Self::CertificateInstallationReq(_) => 7,
            Self::CertificateInstallationRes(_) => 8,
            Self::MeteringConfirmationReq(_) => 16,
            Self::MeteringConfirmationRes(_) => 17,
            Self::PowerDeliveryReq(_) => 21,
            Self::PowerDeliveryRes(_) => 22,
            Self::ScheduleExchangeReq(_) => 27,
            Self::ScheduleExchangeRes(_) => 28,
            Self::ServiceDetailReq(_) => 29,
            Self::ServiceDetailRes(_) => 30,
            Self::ServiceDiscoveryReq(_) => 31,
            Self::ServiceDiscoveryRes(_) => 32,
            Self::ServiceSelectionReq(_) => 33,
            Self::ServiceSelectionRes(_) => 34,
            Self::SessionSetupReq(_) => 35,
            Self::SessionSetupRes(_) => 36,
            Self::SessionStopReq(_) => 37,
            Self::SessionStopRes(_) => 38,
            Self::SignedInstallationData(_) => 45,
            Self::SignedMeteringData(_) => 46,
            Self::VehicleCheckInReq(_) => 49,
            Self::VehicleCheckInRes(_) => 50,
            Self::VehicleCheckOutReq(_) => 51,
            Self::VehicleCheckOutRes(_) => 52,
        }
    }
}

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::AuthorizationReq(m) => m.encode_body(&mut e)?,
            Self::AuthorizationRes(m) => m.encode_body(&mut e)?,
            Self::AuthorizationSetupReq(m) => m.encode_body(&mut e)?,
            Self::AuthorizationSetupRes(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationReq(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationRes(m) => m.encode_body(&mut e)?,
            Self::MeteringConfirmationReq(m) => m.encode_body(&mut e)?,
            Self::MeteringConfirmationRes(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryReq(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryRes(m) => m.encode_body(&mut e)?,
            Self::ScheduleExchangeReq(m) => m.encode_body(&mut e)?,
            Self::ScheduleExchangeRes(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailRes(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::ServiceSelectionReq(m) => m.encode_body(&mut e)?,
            Self::ServiceSelectionRes(m) => m.encode_body(&mut e)?,
            Self::SessionSetupReq(m) => m.encode_body(&mut e)?,
            Self::SessionSetupRes(m) => m.encode_body(&mut e)?,
            Self::SessionStopReq(m) => m.encode_body(&mut e)?,
            Self::SessionStopRes(m) => m.encode_body(&mut e)?,
            Self::SignedInstallationData(m) => m.encode_body(&mut e)?,
            Self::SignedMeteringData(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckInReq(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckInRes(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckOutReq(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckOutRes(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::AuthorizationReq(AuthorizationReq::decode_body(&mut d)?),
            1 => Self::AuthorizationRes(AuthorizationRes::decode_body(&mut d)?),
            2 => Self::AuthorizationSetupReq(AuthorizationSetupReq::decode_body(&mut d)?),
            3 => Self::AuthorizationSetupRes(AuthorizationSetupRes::decode_body(&mut d)?),
            7 => Self::CertificateInstallationReq(CertificateInstallationReq::decode_body(&mut d)?),
            8 => Self::CertificateInstallationRes(CertificateInstallationRes::decode_body(&mut d)?),
            16 => Self::MeteringConfirmationReq(MeteringConfirmationReq::decode_body(&mut d)?),
            17 => Self::MeteringConfirmationRes(MeteringConfirmationRes::decode_body(&mut d)?),
            21 => Self::PowerDeliveryReq(PowerDeliveryReq::decode_body(&mut d)?),
            22 => Self::PowerDeliveryRes(PowerDeliveryRes::decode_body(&mut d)?),
            27 => Self::ScheduleExchangeReq(ScheduleExchangeReq::decode_body(&mut d)?),
            28 => Self::ScheduleExchangeRes(ScheduleExchangeRes::decode_body(&mut d)?),
            29 => Self::ServiceDetailReq(ServiceDetailReq::decode_body(&mut d)?),
            30 => Self::ServiceDetailRes(ServiceDetailRes::decode_body(&mut d)?),
            31 => Self::ServiceDiscoveryReq(ServiceDiscoveryReq::decode_body(&mut d)?),
            32 => Self::ServiceDiscoveryRes(ServiceDiscoveryRes::decode_body(&mut d)?),
            33 => Self::ServiceSelectionReq(ServiceSelectionReq::decode_body(&mut d)?),
            34 => Self::ServiceSelectionRes(ServiceSelectionRes::decode_body(&mut d)?),
            35 => Self::SessionSetupReq(SessionSetupReq::decode_body(&mut d)?),
            36 => Self::SessionSetupRes(SessionSetupRes::decode_body(&mut d)?),
            37 => Self::SessionStopReq(SessionStopReq::decode_body(&mut d)?),
            38 => Self::SessionStopRes(SessionStopRes::decode_body(&mut d)?),
            45 => Self::SignedInstallationData(SignedInstallationData::decode_body(&mut d)?),
            46 => Self::SignedMeteringData(SignedMeteringData::decode_body(&mut d)?),
            49 => Self::VehicleCheckInReq(VehicleCheckInReq::decode_body(&mut d)?),
            50 => Self::VehicleCheckInRes(VehicleCheckInRes::decode_body(&mut d)?),
            51 => Self::VehicleCheckOutReq(VehicleCheckOutReq::decode_body(&mut d)?),
            52 => Self::VehicleCheckOutRes(VehicleCheckOutRes::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::AuthorizationReq(m) => Some(&m.header),
            Self::AuthorizationRes(m) => Some(&m.header),
            Self::AuthorizationSetupReq(m) => Some(&m.header),
            Self::AuthorizationSetupRes(m) => Some(&m.header),
            Self::CertificateInstallationReq(m) => Some(&m.header),
            Self::CertificateInstallationRes(m) => Some(&m.header),
            Self::MeteringConfirmationReq(m) => Some(&m.header),
            Self::MeteringConfirmationRes(m) => Some(&m.header),
            Self::PowerDeliveryReq(m) => Some(&m.header),
            Self::PowerDeliveryRes(m) => Some(&m.header),
            Self::ScheduleExchangeReq(m) => Some(&m.header),
            Self::ScheduleExchangeRes(m) => Some(&m.header),
            Self::ServiceDetailReq(m) => Some(&m.header),
            Self::ServiceDetailRes(m) => Some(&m.header),
            Self::ServiceDiscoveryReq(m) => Some(&m.header),
            Self::ServiceDiscoveryRes(m) => Some(&m.header),
            Self::ServiceSelectionReq(m) => Some(&m.header),
            Self::ServiceSelectionRes(m) => Some(&m.header),
            Self::SessionSetupReq(m) => Some(&m.header),
            Self::SessionSetupRes(m) => Some(&m.header),
            Self::SessionStopReq(m) => Some(&m.header),
            Self::SessionStopRes(m) => Some(&m.header),
            Self::VehicleCheckInReq(m) => Some(&m.header),
            Self::VehicleCheckInRes(m) => Some(&m.header),
            Self::VehicleCheckOutReq(m) => Some(&m.header),
            Self::VehicleCheckOutRes(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::AuthorizationReq(m) => Some(&mut m.header),
            Self::AuthorizationRes(m) => Some(&mut m.header),
            Self::AuthorizationSetupReq(m) => Some(&mut m.header),
            Self::AuthorizationSetupRes(m) => Some(&mut m.header),
            Self::CertificateInstallationReq(m) => Some(&mut m.header),
            Self::CertificateInstallationRes(m) => Some(&mut m.header),
            Self::MeteringConfirmationReq(m) => Some(&mut m.header),
            Self::MeteringConfirmationRes(m) => Some(&mut m.header),
            Self::PowerDeliveryReq(m) => Some(&mut m.header),
            Self::PowerDeliveryRes(m) => Some(&mut m.header),
            Self::ScheduleExchangeReq(m) => Some(&mut m.header),
            Self::ScheduleExchangeRes(m) => Some(&mut m.header),
            Self::ServiceDetailReq(m) => Some(&mut m.header),
            Self::ServiceDetailRes(m) => Some(&mut m.header),
            Self::ServiceDiscoveryReq(m) => Some(&mut m.header),
            Self::ServiceDiscoveryRes(m) => Some(&mut m.header),
            Self::ServiceSelectionReq(m) => Some(&mut m.header),
            Self::ServiceSelectionRes(m) => Some(&mut m.header),
            Self::SessionSetupReq(m) => Some(&mut m.header),
            Self::SessionSetupRes(m) => Some(&mut m.header),
            Self::SessionStopReq(m) => Some(&mut m.header),
            Self::SessionStopRes(m) => Some(&mut m.header),
            Self::VehicleCheckInReq(m) => Some(&mut m.header),
            Self::VehicleCheckInRes(m) => Some(&mut m.header),
            Self::VehicleCheckOutReq(m) => Some(&mut m.header),
            Self::VehicleCheckOutRes(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::AuthorizationRes(m) => Some(m.response_code),
            Self::AuthorizationSetupRes(m) => Some(m.response_code),
            Self::CertificateInstallationRes(m) => Some(m.response_code),
            Self::MeteringConfirmationRes(m) => Some(m.response_code),
            Self::PowerDeliveryRes(m) => Some(m.response_code),
            Self::ScheduleExchangeRes(m) => Some(m.response_code),
            Self::ServiceDetailRes(m) => Some(m.response_code),
            Self::ServiceDiscoveryRes(m) => Some(m.response_code),
            Self::ServiceSelectionRes(m) => Some(m.response_code),
            Self::SessionSetupRes(m) => Some(m.response_code),
            Self::SessionStopRes(m) => Some(m.response_code),
            Self::VehicleCheckInRes(m) => Some(m.response_code),
            Self::VehicleCheckOutRes(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::AuthorizationReq(_) => 10,
            Self::AuthorizationRes(_) => 11,
            Self::AuthorizationSetupReq(_) => 13,
            Self::AuthorizationSetupRes(_) => 14,
            Self::CertificateInstallationReq(_) => 27,
            Self::CertificateInstallationRes(_) => 28,
            Self::MeteringConfirmationReq(_) => 119,
            Self::MeteringConfirmationRes(_) => 120,
            Self::PowerDeliveryReq(_) => 154,
            Self::PowerDeliveryRes(_) => 155,
            Self::ScheduleExchangeReq(_) => 193,
            Self::ScheduleExchangeRes(_) => 194,
            Self::ServiceDetailReq(_) => 208,
            Self::ServiceDetailRes(_) => 209,
            Self::ServiceDiscoveryReq(_) => 210,
            Self::ServiceDiscoveryRes(_) => 211,
            Self::ServiceSelectionReq(_) => 217,
            Self::ServiceSelectionRes(_) => 218,
            Self::SessionSetupReq(_) => 221,
            Self::SessionSetupRes(_) => 222,
            Self::SessionStopReq(_) => 223,
            Self::SessionStopRes(_) => 224,
            Self::SignedInstallationData(_) => 231,
            Self::SignedMeteringData(_) => 232,
            Self::VehicleCheckInReq(_) => 258,
            Self::VehicleCheckInRes(_) => 259,
            Self::VehicleCheckOutReq(_) => 260,
            Self::VehicleCheckOutRes(_) => 261,
        }
    }

    /// 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::AuthorizationReq(m) => m.encode_body(&mut e)?,
            Self::AuthorizationRes(m) => m.encode_body(&mut e)?,
            Self::AuthorizationSetupReq(m) => m.encode_body(&mut e)?,
            Self::AuthorizationSetupRes(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationReq(m) => m.encode_body(&mut e)?,
            Self::CertificateInstallationRes(m) => m.encode_body(&mut e)?,
            Self::MeteringConfirmationReq(m) => m.encode_body(&mut e)?,
            Self::MeteringConfirmationRes(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryReq(m) => m.encode_body(&mut e)?,
            Self::PowerDeliveryRes(m) => m.encode_body(&mut e)?,
            Self::ScheduleExchangeReq(m) => m.encode_body(&mut e)?,
            Self::ScheduleExchangeRes(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDetailRes(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryReq(m) => m.encode_body(&mut e)?,
            Self::ServiceDiscoveryRes(m) => m.encode_body(&mut e)?,
            Self::ServiceSelectionReq(m) => m.encode_body(&mut e)?,
            Self::ServiceSelectionRes(m) => m.encode_body(&mut e)?,
            Self::SessionSetupReq(m) => m.encode_body(&mut e)?,
            Self::SessionSetupRes(m) => m.encode_body(&mut e)?,
            Self::SessionStopReq(m) => m.encode_body(&mut e)?,
            Self::SessionStopRes(m) => m.encode_body(&mut e)?,
            Self::SignedInstallationData(m) => m.encode_body(&mut e)?,
            Self::SignedMeteringData(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckInReq(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckInRes(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckOutReq(m) => m.encode_body(&mut e)?,
            Self::VehicleCheckOutRes(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)? {
            10 => Self::AuthorizationReq(AuthorizationReq::decode_body(&mut d)?),
            11 => Self::AuthorizationRes(AuthorizationRes::decode_body(&mut d)?),
            13 => Self::AuthorizationSetupReq(AuthorizationSetupReq::decode_body(&mut d)?),
            14 => Self::AuthorizationSetupRes(AuthorizationSetupRes::decode_body(&mut d)?),
            27 => {
                Self::CertificateInstallationReq(CertificateInstallationReq::decode_body(&mut d)?)
            }
            28 => {
                Self::CertificateInstallationRes(CertificateInstallationRes::decode_body(&mut d)?)
            }
            119 => Self::MeteringConfirmationReq(MeteringConfirmationReq::decode_body(&mut d)?),
            120 => Self::MeteringConfirmationRes(MeteringConfirmationRes::decode_body(&mut d)?),
            154 => Self::PowerDeliveryReq(PowerDeliveryReq::decode_body(&mut d)?),
            155 => Self::PowerDeliveryRes(PowerDeliveryRes::decode_body(&mut d)?),
            193 => Self::ScheduleExchangeReq(ScheduleExchangeReq::decode_body(&mut d)?),
            194 => Self::ScheduleExchangeRes(ScheduleExchangeRes::decode_body(&mut d)?),
            208 => Self::ServiceDetailReq(ServiceDetailReq::decode_body(&mut d)?),
            209 => Self::ServiceDetailRes(ServiceDetailRes::decode_body(&mut d)?),
            210 => Self::ServiceDiscoveryReq(ServiceDiscoveryReq::decode_body(&mut d)?),
            211 => Self::ServiceDiscoveryRes(ServiceDiscoveryRes::decode_body(&mut d)?),
            217 => Self::ServiceSelectionReq(ServiceSelectionReq::decode_body(&mut d)?),
            218 => Self::ServiceSelectionRes(ServiceSelectionRes::decode_body(&mut d)?),
            221 => Self::SessionSetupReq(SessionSetupReq::decode_body(&mut d)?),
            222 => Self::SessionSetupRes(SessionSetupRes::decode_body(&mut d)?),
            223 => Self::SessionStopReq(SessionStopReq::decode_body(&mut d)?),
            224 => Self::SessionStopRes(SessionStopRes::decode_body(&mut d)?),
            231 => Self::SignedInstallationData(SignedInstallationData::decode_body(&mut d)?),
            232 => Self::SignedMeteringData(SignedMeteringData::decode_body(&mut d)?),
            258 => Self::VehicleCheckInReq(VehicleCheckInReq::decode_body(&mut d)?),
            259 => Self::VehicleCheckInRes(VehicleCheckInRes::decode_body(&mut d)?),
            260 => Self::VehicleCheckOutReq(VehicleCheckOutReq::decode_body(&mut d)?),
            261 => Self::VehicleCheckOutRes(VehicleCheckOutRes::decode_body(&mut d)?),
            _ => return Err(ExiError::UnknownEventCode),
        };
        d.expect_event(FRAGMENT_ED_CODE, FRAGMENT_WIDTH)?;
        d.finish()?;
        Ok(value)
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl ContractCertificateChain {
    /// Fragment event code of `ContractCertificateChain` 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(ContractCertificateChain) … 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 DynamicEVPPTControlMode {
    /// Fragment event code of `Dynamic_EVPPTControlMode` in this schema set.
    pub const FRAGMENT_CODE: u64 = 50;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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