codetics_ocpp21/

enums.rs

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Kevin Vavelin, Codetics (https://codetics.fr)

//! OCPP 2.1 enumerations.

use ocpp_core::validate::{Path, Validate, Violation};
use serde::{Deserialize, Serialize};

/// Authentication method.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum APNAuthenticationEnum {
    #[serde(rename = "PAP")]
    PAP,
    #[serde(rename = "CHAP")]
    CHAP,
    #[serde(rename = "NONE")]
    NONE,
    #[serde(rename = "AUTO")]
    AUTO,
}

impl APNAuthenticationEnum {
    pub const ALL: &'static [APNAuthenticationEnum] = &[
        APNAuthenticationEnum::PAP,
        APNAuthenticationEnum::CHAP,
        APNAuthenticationEnum::NONE,
        APNAuthenticationEnum::AUTO,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            APNAuthenticationEnum::PAP => "PAP",
            APNAuthenticationEnum::CHAP => "CHAP",
            APNAuthenticationEnum::NONE => "NONE",
            APNAuthenticationEnum::AUTO => "AUTO",
        }
    }
}

impl std::fmt::Display for APNAuthenticationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for APNAuthenticationEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for APNAuthenticationEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Attribute type for which value is requested. When absent, default Actual is assumed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AttributeEnum {
    #[serde(rename = "Actual")]
    Actual,
    #[serde(rename = "Target")]
    Target,
    #[serde(rename = "MinSet")]
    MinSet,
    #[serde(rename = "MaxSet")]
    MaxSet,
}

impl AttributeEnum {
    pub const ALL: &'static [AttributeEnum] = &[
        AttributeEnum::Actual,
        AttributeEnum::Target,
        AttributeEnum::MinSet,
        AttributeEnum::MaxSet,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            AttributeEnum::Actual => "Actual",
            AttributeEnum::Target => "Target",
            AttributeEnum::MinSet => "MinSet",
            AttributeEnum::MaxSet => "MaxSet",
        }
    }
}

impl std::fmt::Display for AttributeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for AttributeEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for AttributeEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Current status of the ID Token.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AuthorizationStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Blocked")]
    Blocked,
    #[serde(rename = "ConcurrentTx")]
    ConcurrentTx,
    #[serde(rename = "Expired")]
    Expired,
    #[serde(rename = "Invalid")]
    Invalid,
    #[serde(rename = "NoCredit")]
    NoCredit,
    #[serde(rename = "NotAllowedTypeEVSE")]
    NotAllowedTypeEVSE,
    #[serde(rename = "NotAtThisLocation")]
    NotAtThisLocation,
    #[serde(rename = "NotAtThisTime")]
    NotAtThisTime,
    #[serde(rename = "Unknown")]
    Unknown,
}

impl AuthorizationStatusEnum {
    pub const ALL: &'static [AuthorizationStatusEnum] = &[
        AuthorizationStatusEnum::Accepted,
        AuthorizationStatusEnum::Blocked,
        AuthorizationStatusEnum::ConcurrentTx,
        AuthorizationStatusEnum::Expired,
        AuthorizationStatusEnum::Invalid,
        AuthorizationStatusEnum::NoCredit,
        AuthorizationStatusEnum::NotAllowedTypeEVSE,
        AuthorizationStatusEnum::NotAtThisLocation,
        AuthorizationStatusEnum::NotAtThisTime,
        AuthorizationStatusEnum::Unknown,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            AuthorizationStatusEnum::Accepted => "Accepted",
            AuthorizationStatusEnum::Blocked => "Blocked",
            AuthorizationStatusEnum::ConcurrentTx => "ConcurrentTx",
            AuthorizationStatusEnum::Expired => "Expired",
            AuthorizationStatusEnum::Invalid => "Invalid",
            AuthorizationStatusEnum::NoCredit => "NoCredit",
            AuthorizationStatusEnum::NotAllowedTypeEVSE => "NotAllowedTypeEVSE",
            AuthorizationStatusEnum::NotAtThisLocation => "NotAtThisLocation",
            AuthorizationStatusEnum::NotAtThisTime => "NotAtThisTime",
            AuthorizationStatusEnum::Unknown => "Unknown",
        }
    }
}

impl std::fmt::Display for AuthorizationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for AuthorizationStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for AuthorizationStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Certificate status information.
/// - if all certificates are valid: return 'Accepted'.
/// - if one of the certificates was revoked, return 'CertificateRevoked'.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AuthorizeCertificateStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "SignatureError")]
    SignatureError,
    #[serde(rename = "CertificateExpired")]
    CertificateExpired,
    #[serde(rename = "CertificateRevoked")]
    CertificateRevoked,
    #[serde(rename = "NoCertificateAvailable")]
    NoCertificateAvailable,
    #[serde(rename = "CertChainError")]
    CertChainError,
    #[serde(rename = "ContractCancelled")]
    ContractCancelled,
}

impl AuthorizeCertificateStatusEnum {
    pub const ALL: &'static [AuthorizeCertificateStatusEnum] = &[
        AuthorizeCertificateStatusEnum::Accepted,
        AuthorizeCertificateStatusEnum::SignatureError,
        AuthorizeCertificateStatusEnum::CertificateExpired,
        AuthorizeCertificateStatusEnum::CertificateRevoked,
        AuthorizeCertificateStatusEnum::NoCertificateAvailable,
        AuthorizeCertificateStatusEnum::CertChainError,
        AuthorizeCertificateStatusEnum::ContractCancelled,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            AuthorizeCertificateStatusEnum::Accepted => "Accepted",
            AuthorizeCertificateStatusEnum::SignatureError => "SignatureError",
            AuthorizeCertificateStatusEnum::CertificateExpired => "CertificateExpired",
            AuthorizeCertificateStatusEnum::CertificateRevoked => "CertificateRevoked",
            AuthorizeCertificateStatusEnum::NoCertificateAvailable => "NoCertificateAvailable",
            AuthorizeCertificateStatusEnum::CertChainError => "CertChainError",
            AuthorizeCertificateStatusEnum::ContractCancelled => "ContractCancelled",
        }
    }
}

impl std::fmt::Display for AuthorizeCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for AuthorizeCertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for AuthorizeCertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Battery in/out
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BatterySwapEventEnum {
    #[serde(rename = "BatteryIn")]
    BatteryIn,
    #[serde(rename = "BatteryOut")]
    BatteryOut,
    #[serde(rename = "BatteryOutTimeout")]
    BatteryOutTimeout,
}

impl BatterySwapEventEnum {
    pub const ALL: &'static [BatterySwapEventEnum] = &[
        BatterySwapEventEnum::BatteryIn,
        BatterySwapEventEnum::BatteryOut,
        BatterySwapEventEnum::BatteryOutTimeout,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            BatterySwapEventEnum::BatteryIn => "BatteryIn",
            BatterySwapEventEnum::BatteryOut => "BatteryOut",
            BatterySwapEventEnum::BatteryOutTimeout => "BatteryOutTimeout",
        }
    }
}

impl std::fmt::Display for BatterySwapEventEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for BatterySwapEventEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for BatterySwapEventEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the reason for sending this message to the CSMS.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BootReasonEnum {
    #[serde(rename = "ApplicationReset")]
    ApplicationReset,
    #[serde(rename = "FirmwareUpdate")]
    FirmwareUpdate,
    #[serde(rename = "LocalReset")]
    LocalReset,
    #[serde(rename = "PowerUp")]
    PowerUp,
    #[serde(rename = "RemoteReset")]
    RemoteReset,
    #[serde(rename = "ScheduledReset")]
    ScheduledReset,
    #[serde(rename = "Triggered")]
    Triggered,
    #[serde(rename = "Unknown")]
    Unknown,
    #[serde(rename = "Watchdog")]
    Watchdog,
}

impl BootReasonEnum {
    pub const ALL: &'static [BootReasonEnum] = &[
        BootReasonEnum::ApplicationReset,
        BootReasonEnum::FirmwareUpdate,
        BootReasonEnum::LocalReset,
        BootReasonEnum::PowerUp,
        BootReasonEnum::RemoteReset,
        BootReasonEnum::ScheduledReset,
        BootReasonEnum::Triggered,
        BootReasonEnum::Unknown,
        BootReasonEnum::Watchdog,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            BootReasonEnum::ApplicationReset => "ApplicationReset",
            BootReasonEnum::FirmwareUpdate => "FirmwareUpdate",
            BootReasonEnum::LocalReset => "LocalReset",
            BootReasonEnum::PowerUp => "PowerUp",
            BootReasonEnum::RemoteReset => "RemoteReset",
            BootReasonEnum::ScheduledReset => "ScheduledReset",
            BootReasonEnum::Triggered => "Triggered",
            BootReasonEnum::Unknown => "Unknown",
            BootReasonEnum::Watchdog => "Watchdog",
        }
    }
}

impl std::fmt::Display for BootReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for BootReasonEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for BootReasonEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates the success or failure of the canceling of a reservation by CSMS.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CancelReservationStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl CancelReservationStatusEnum {
    pub const ALL: &'static [CancelReservationStatusEnum] = &[
        CancelReservationStatusEnum::Accepted,
        CancelReservationStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CancelReservationStatusEnum::Accepted => "Accepted",
            CancelReservationStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for CancelReservationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CancelReservationStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CancelReservationStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Defines whether certificate needs to be installed or updated.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CertificateActionEnum {
    #[serde(rename = "Install")]
    Install,
    #[serde(rename = "Update")]
    Update,
}

impl CertificateActionEnum {
    pub const ALL: &'static [CertificateActionEnum] = &[
        CertificateActionEnum::Install,
        CertificateActionEnum::Update,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CertificateActionEnum::Install => "Install",
            CertificateActionEnum::Update => "Update",
        }
    }
}

impl std::fmt::Display for CertificateActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CertificateActionEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CertificateActionEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Returns whether certificate signing has been accepted, otherwise rejected.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CertificateSignedStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl CertificateSignedStatusEnum {
    pub const ALL: &'static [CertificateSignedStatusEnum] = &[
        CertificateSignedStatusEnum::Accepted,
        CertificateSignedStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CertificateSignedStatusEnum::Accepted => "Accepted",
            CertificateSignedStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for CertificateSignedStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CertificateSignedStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CertificateSignedStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates the type of the signed certificate that is returned. When omitted the certificate is used for both the 15118 connection (if implemented) and the Charging Station to CSMS connection. This field is required when a typeOfCertificate was included in the &lt;&lt;signcertificaterequest,SignCertificateRequest&gt;&gt; that requested this certificate to be signed AND both the 15118 connection and the Charging Station connection are implemented.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CertificateSigningUseEnum {
    #[serde(rename = "ChargingStationCertificate")]
    ChargingStationCertificate,
    #[serde(rename = "V2GCertificate")]
    V2GCertificate,
    #[serde(rename = "V2G20Certificate")]
    V2G20Certificate,
}

impl CertificateSigningUseEnum {
    pub const ALL: &'static [CertificateSigningUseEnum] = &[
        CertificateSigningUseEnum::ChargingStationCertificate,
        CertificateSigningUseEnum::V2GCertificate,
        CertificateSigningUseEnum::V2G20Certificate,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CertificateSigningUseEnum::ChargingStationCertificate => "ChargingStationCertificate",
            CertificateSigningUseEnum::V2GCertificate => "V2GCertificate",
            CertificateSigningUseEnum::V2G20Certificate => "V2G20Certificate",
        }
    }
}

impl std::fmt::Display for CertificateSigningUseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CertificateSigningUseEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CertificateSigningUseEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Status of certificate: good, revoked or unknown.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CertificateStatusEnum {
    #[serde(rename = "Good")]
    Good,
    #[serde(rename = "Revoked")]
    Revoked,
    #[serde(rename = "Unknown")]
    Unknown,
    #[serde(rename = "Failed")]
    Failed,
}

impl CertificateStatusEnum {
    pub const ALL: &'static [CertificateStatusEnum] = &[
        CertificateStatusEnum::Good,
        CertificateStatusEnum::Revoked,
        CertificateStatusEnum::Unknown,
        CertificateStatusEnum::Failed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CertificateStatusEnum::Good => "Good",
            CertificateStatusEnum::Revoked => "Revoked",
            CertificateStatusEnum::Unknown => "Unknown",
            CertificateStatusEnum::Failed => "Failed",
        }
    }
}

impl std::fmt::Display for CertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Source of status: OCSP, CRL
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CertificateStatusSourceEnum {
    #[serde(rename = "CRL")]
    CRL,
    #[serde(rename = "OCSP")]
    OCSP,
}

impl CertificateStatusSourceEnum {
    pub const ALL: &'static [CertificateStatusSourceEnum] = &[
        CertificateStatusSourceEnum::CRL,
        CertificateStatusSourceEnum::OCSP,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CertificateStatusSourceEnum::CRL => "CRL",
            CertificateStatusSourceEnum::OCSP => "OCSP",
        }
    }
}

impl std::fmt::Display for CertificateStatusSourceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CertificateStatusSourceEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CertificateStatusSourceEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station is able to perform the availability change.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChangeAvailabilityStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Scheduled")]
    Scheduled,
}

impl ChangeAvailabilityStatusEnum {
    pub const ALL: &'static [ChangeAvailabilityStatusEnum] = &[
        ChangeAvailabilityStatusEnum::Accepted,
        ChangeAvailabilityStatusEnum::Rejected,
        ChangeAvailabilityStatusEnum::Scheduled,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ChangeAvailabilityStatusEnum::Accepted => "Accepted",
            ChangeAvailabilityStatusEnum::Rejected => "Rejected",
            ChangeAvailabilityStatusEnum::Scheduled => "Scheduled",
        }
    }
}

impl std::fmt::Display for ChangeAvailabilityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ChangeAvailabilityStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ChangeAvailabilityStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates the kind of schedule.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingProfileKindEnum {
    #[serde(rename = "Absolute")]
    Absolute,
    #[serde(rename = "Recurring")]
    Recurring,
    #[serde(rename = "Relative")]
    Relative,
    #[serde(rename = "Dynamic")]
    Dynamic,
}

impl ChargingProfileKindEnum {
    pub const ALL: &'static [ChargingProfileKindEnum] = &[
        ChargingProfileKindEnum::Absolute,
        ChargingProfileKindEnum::Recurring,
        ChargingProfileKindEnum::Relative,
        ChargingProfileKindEnum::Dynamic,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ChargingProfileKindEnum::Absolute => "Absolute",
            ChargingProfileKindEnum::Recurring => "Recurring",
            ChargingProfileKindEnum::Relative => "Relative",
            ChargingProfileKindEnum::Dynamic => "Dynamic",
        }
    }
}

impl std::fmt::Display for ChargingProfileKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ChargingProfileKindEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ChargingProfileKindEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Specifies to purpose of the charging profiles that will be cleared, if they meet the other criteria in the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingProfilePurposeEnum {
    #[serde(rename = "ChargingStationExternalConstraints")]
    ChargingStationExternalConstraints,
    #[serde(rename = "ChargingStationMaxProfile")]
    ChargingStationMaxProfile,
    #[serde(rename = "TxDefaultProfile")]
    TxDefaultProfile,
    #[serde(rename = "TxProfile")]
    TxProfile,
    #[serde(rename = "PriorityCharging")]
    PriorityCharging,
    #[serde(rename = "LocalGeneration")]
    LocalGeneration,
}

impl ChargingProfilePurposeEnum {
    pub const ALL: &'static [ChargingProfilePurposeEnum] = &[
        ChargingProfilePurposeEnum::ChargingStationExternalConstraints,
        ChargingProfilePurposeEnum::ChargingStationMaxProfile,
        ChargingProfilePurposeEnum::TxDefaultProfile,
        ChargingProfilePurposeEnum::TxProfile,
        ChargingProfilePurposeEnum::PriorityCharging,
        ChargingProfilePurposeEnum::LocalGeneration,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ChargingProfilePurposeEnum::ChargingStationExternalConstraints => {
                "ChargingStationExternalConstraints"
            }
            ChargingProfilePurposeEnum::ChargingStationMaxProfile => "ChargingStationMaxProfile",
            ChargingProfilePurposeEnum::TxDefaultProfile => "TxDefaultProfile",
            ChargingProfilePurposeEnum::TxProfile => "TxProfile",
            ChargingProfilePurposeEnum::PriorityCharging => "PriorityCharging",
            ChargingProfilePurposeEnum::LocalGeneration => "LocalGeneration",
        }
    }
}

impl std::fmt::Display for ChargingProfilePurposeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ChargingProfilePurposeEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ChargingProfilePurposeEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Result of request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingProfileStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl ChargingProfileStatusEnum {
    pub const ALL: &'static [ChargingProfileStatusEnum] = &[
        ChargingProfileStatusEnum::Accepted,
        ChargingProfileStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ChargingProfileStatusEnum::Accepted => "Accepted",
            ChargingProfileStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for ChargingProfileStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ChargingProfileStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ChargingProfileStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Can be used to force a power or current profile.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingRateUnitEnum {
    #[serde(rename = "W")]
    W,
    #[serde(rename = "A")]
    A,
}

impl ChargingRateUnitEnum {
    pub const ALL: &'static [ChargingRateUnitEnum] =
        &[ChargingRateUnitEnum::W, ChargingRateUnitEnum::A];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ChargingRateUnitEnum::W => "W",
            ChargingRateUnitEnum::A => "A",
        }
    }
}

impl std::fmt::Display for ChargingRateUnitEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ChargingRateUnitEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ChargingRateUnitEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Current charging state, is required when state
/// has changed. Omitted when there is no communication between EVSE and EV, because no cable is plugged in.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingStateEnum {
    #[serde(rename = "EVConnected")]
    EVConnected,
    #[serde(rename = "Charging")]
    Charging,
    #[serde(rename = "SuspendedEV")]
    SuspendedEV,
    #[serde(rename = "SuspendedEVSE")]
    SuspendedEVSE,
    #[serde(rename = "Idle")]
    Idle,
}

impl ChargingStateEnum {
    pub const ALL: &'static [ChargingStateEnum] = &[
        ChargingStateEnum::EVConnected,
        ChargingStateEnum::Charging,
        ChargingStateEnum::SuspendedEV,
        ChargingStateEnum::SuspendedEVSE,
        ChargingStateEnum::Idle,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ChargingStateEnum::EVConnected => "EVConnected",
            ChargingStateEnum::Charging => "Charging",
            ChargingStateEnum::SuspendedEV => "SuspendedEV",
            ChargingStateEnum::SuspendedEVSE => "SuspendedEVSE",
            ChargingStateEnum::Idle => "Idle",
        }
    }
}

impl std::fmt::Display for ChargingStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ChargingStateEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ChargingStateEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Accepted if the Charging Station has executed the request, otherwise rejected.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ClearCacheStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl ClearCacheStatusEnum {
    pub const ALL: &'static [ClearCacheStatusEnum] = &[
        ClearCacheStatusEnum::Accepted,
        ClearCacheStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ClearCacheStatusEnum::Accepted => "Accepted",
            ClearCacheStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for ClearCacheStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ClearCacheStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ClearCacheStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates if the Charging Station was able to execute the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ClearChargingProfileStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Unknown")]
    Unknown,
}

impl ClearChargingProfileStatusEnum {
    pub const ALL: &'static [ClearChargingProfileStatusEnum] = &[
        ClearChargingProfileStatusEnum::Accepted,
        ClearChargingProfileStatusEnum::Unknown,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ClearChargingProfileStatusEnum::Accepted => "Accepted",
            ClearChargingProfileStatusEnum::Unknown => "Unknown",
        }
    }
}

impl std::fmt::Display for ClearChargingProfileStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ClearChargingProfileStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ClearChargingProfileStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Returns whether the Charging Station has been able to remove the message.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ClearMessageStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Unknown")]
    Unknown,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl ClearMessageStatusEnum {
    pub const ALL: &'static [ClearMessageStatusEnum] = &[
        ClearMessageStatusEnum::Accepted,
        ClearMessageStatusEnum::Unknown,
        ClearMessageStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ClearMessageStatusEnum::Accepted => "Accepted",
            ClearMessageStatusEnum::Unknown => "Unknown",
            ClearMessageStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for ClearMessageStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ClearMessageStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ClearMessageStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Result of the clear request for this monitor, identified by its Id.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ClearMonitoringStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NotFound")]
    NotFound,
}

impl ClearMonitoringStatusEnum {
    pub const ALL: &'static [ClearMonitoringStatusEnum] = &[
        ClearMonitoringStatusEnum::Accepted,
        ClearMonitoringStatusEnum::Rejected,
        ClearMonitoringStatusEnum::NotFound,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ClearMonitoringStatusEnum::Accepted => "Accepted",
            ClearMonitoringStatusEnum::Rejected => "Rejected",
            ClearMonitoringStatusEnum::NotFound => "NotFound",
        }
    }
}

impl std::fmt::Display for ClearMonitoringStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ClearMonitoringStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ClearMonitoringStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ComponentCriterionEnum {
    #[serde(rename = "Active")]
    Active,
    #[serde(rename = "Available")]
    Available,
    #[serde(rename = "Enabled")]
    Enabled,
    #[serde(rename = "Problem")]
    Problem,
}

impl ComponentCriterionEnum {
    pub const ALL: &'static [ComponentCriterionEnum] = &[
        ComponentCriterionEnum::Active,
        ComponentCriterionEnum::Available,
        ComponentCriterionEnum::Enabled,
        ComponentCriterionEnum::Problem,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ComponentCriterionEnum::Active => "Active",
            ComponentCriterionEnum::Available => "Available",
            ComponentCriterionEnum::Enabled => "Enabled",
            ComponentCriterionEnum::Problem => "Problem",
        }
    }
}

impl std::fmt::Display for ComponentCriterionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ComponentCriterionEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ComponentCriterionEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the current status of the Connector.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ConnectorStatusEnum {
    #[serde(rename = "Available")]
    Available,
    #[serde(rename = "Occupied")]
    Occupied,
    #[serde(rename = "Reserved")]
    Reserved,
    #[serde(rename = "Unavailable")]
    Unavailable,
    #[serde(rename = "Faulted")]
    Faulted,
}

impl ConnectorStatusEnum {
    pub const ALL: &'static [ConnectorStatusEnum] = &[
        ConnectorStatusEnum::Available,
        ConnectorStatusEnum::Occupied,
        ConnectorStatusEnum::Reserved,
        ConnectorStatusEnum::Unavailable,
        ConnectorStatusEnum::Faulted,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ConnectorStatusEnum::Available => "Available",
            ConnectorStatusEnum::Occupied => "Occupied",
            ConnectorStatusEnum::Reserved => "Reserved",
            ConnectorStatusEnum::Unavailable => "Unavailable",
            ConnectorStatusEnum::Faulted => "Faulted",
        }
    }
}

impl std::fmt::Display for ConnectorStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ConnectorStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ConnectorStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// *(2.1)* Indicates whether EV wants to operate in Dynamic or Scheduled mode. When absent, Scheduled mode is assumed for backwards compatibility. +
/// *ISO 15118-20:* +
/// ServiceSelectionReq(SelectedEnergyTransferService)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ControlModeEnum {
    #[serde(rename = "ScheduledControl")]
    ScheduledControl,
    #[serde(rename = "DynamicControl")]
    DynamicControl,
}

impl ControlModeEnum {
    pub const ALL: &'static [ControlModeEnum] = &[
        ControlModeEnum::ScheduledControl,
        ControlModeEnum::DynamicControl,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ControlModeEnum::ScheduledControl => "ScheduledControl",
            ControlModeEnum::DynamicControl => "DynamicControl",
        }
    }
}

impl std::fmt::Display for ControlModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ControlModeEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ControlModeEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of cost dimension: energy, power, time, etc.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CostDimensionEnum {
    #[serde(rename = "Energy")]
    Energy,
    #[serde(rename = "MaxCurrent")]
    MaxCurrent,
    #[serde(rename = "MinCurrent")]
    MinCurrent,
    #[serde(rename = "MaxPower")]
    MaxPower,
    #[serde(rename = "MinPower")]
    MinPower,
    #[serde(rename = "IdleTIme")]
    IdleTIme,
    #[serde(rename = "ChargingTime")]
    ChargingTime,
}

impl CostDimensionEnum {
    pub const ALL: &'static [CostDimensionEnum] = &[
        CostDimensionEnum::Energy,
        CostDimensionEnum::MaxCurrent,
        CostDimensionEnum::MinCurrent,
        CostDimensionEnum::MaxPower,
        CostDimensionEnum::MinPower,
        CostDimensionEnum::IdleTIme,
        CostDimensionEnum::ChargingTime,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CostDimensionEnum::Energy => "Energy",
            CostDimensionEnum::MaxCurrent => "MaxCurrent",
            CostDimensionEnum::MinCurrent => "MinCurrent",
            CostDimensionEnum::MaxPower => "MaxPower",
            CostDimensionEnum::MinPower => "MinPower",
            CostDimensionEnum::IdleTIme => "IdleTIme",
            CostDimensionEnum::ChargingTime => "ChargingTime",
        }
    }
}

impl std::fmt::Display for CostDimensionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CostDimensionEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CostDimensionEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// The kind of cost referred to in the message element amount
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CostKindEnum {
    #[serde(rename = "CarbonDioxideEmission")]
    CarbonDioxideEmission,
    #[serde(rename = "RelativePricePercentage")]
    RelativePricePercentage,
    #[serde(rename = "RenewableGenerationPercentage")]
    RenewableGenerationPercentage,
}

impl CostKindEnum {
    pub const ALL: &'static [CostKindEnum] = &[
        CostKindEnum::CarbonDioxideEmission,
        CostKindEnum::RelativePricePercentage,
        CostKindEnum::RenewableGenerationPercentage,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CostKindEnum::CarbonDioxideEmission => "CarbonDioxideEmission",
            CostKindEnum::RelativePricePercentage => "RelativePricePercentage",
            CostKindEnum::RenewableGenerationPercentage => "RenewableGenerationPercentage",
        }
    }
}

impl std::fmt::Display for CostKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CostKindEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CostKindEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates whether the request was accepted.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CustomerInformationStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Invalid")]
    Invalid,
}

impl CustomerInformationStatusEnum {
    pub const ALL: &'static [CustomerInformationStatusEnum] = &[
        CustomerInformationStatusEnum::Accepted,
        CustomerInformationStatusEnum::Rejected,
        CustomerInformationStatusEnum::Invalid,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            CustomerInformationStatusEnum::Accepted => "Accepted",
            CustomerInformationStatusEnum::Rejected => "Rejected",
            CustomerInformationStatusEnum::Invalid => "Invalid",
        }
    }
}

impl std::fmt::Display for CustomerInformationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for CustomerInformationStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for CustomerInformationStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Name of control settings to clear. Not used when _controlId_ is provided.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DERControlEnum {
    #[serde(rename = "EnterService")]
    EnterService,
    #[serde(rename = "FreqDroop")]
    FreqDroop,
    #[serde(rename = "FreqWatt")]
    FreqWatt,
    #[serde(rename = "FixedPFAbsorb")]
    FixedPFAbsorb,
    #[serde(rename = "FixedPFInject")]
    FixedPFInject,
    #[serde(rename = "FixedVar")]
    FixedVar,
    #[serde(rename = "Gradients")]
    Gradients,
    #[serde(rename = "HFMustTrip")]
    HFMustTrip,
    #[serde(rename = "HFMayTrip")]
    HFMayTrip,
    #[serde(rename = "HVMustTrip")]
    HVMustTrip,
    #[serde(rename = "HVMomCess")]
    HVMomCess,
    #[serde(rename = "HVMayTrip")]
    HVMayTrip,
    #[serde(rename = "LimitMaxDischarge")]
    LimitMaxDischarge,
    #[serde(rename = "LFMustTrip")]
    LFMustTrip,
    #[serde(rename = "LVMustTrip")]
    LVMustTrip,
    #[serde(rename = "LVMomCess")]
    LVMomCess,
    #[serde(rename = "LVMayTrip")]
    LVMayTrip,
    #[serde(rename = "PowerMonitoringMustTrip")]
    PowerMonitoringMustTrip,
    #[serde(rename = "VoltVar")]
    VoltVar,
    #[serde(rename = "VoltWatt")]
    VoltWatt,
    #[serde(rename = "WattPF")]
    WattPF,
    #[serde(rename = "WattVar")]
    WattVar,
}

impl DERControlEnum {
    pub const ALL: &'static [DERControlEnum] = &[
        DERControlEnum::EnterService,
        DERControlEnum::FreqDroop,
        DERControlEnum::FreqWatt,
        DERControlEnum::FixedPFAbsorb,
        DERControlEnum::FixedPFInject,
        DERControlEnum::FixedVar,
        DERControlEnum::Gradients,
        DERControlEnum::HFMustTrip,
        DERControlEnum::HFMayTrip,
        DERControlEnum::HVMustTrip,
        DERControlEnum::HVMomCess,
        DERControlEnum::HVMayTrip,
        DERControlEnum::LimitMaxDischarge,
        DERControlEnum::LFMustTrip,
        DERControlEnum::LVMustTrip,
        DERControlEnum::LVMomCess,
        DERControlEnum::LVMayTrip,
        DERControlEnum::PowerMonitoringMustTrip,
        DERControlEnum::VoltVar,
        DERControlEnum::VoltWatt,
        DERControlEnum::WattPF,
        DERControlEnum::WattVar,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DERControlEnum::EnterService => "EnterService",
            DERControlEnum::FreqDroop => "FreqDroop",
            DERControlEnum::FreqWatt => "FreqWatt",
            DERControlEnum::FixedPFAbsorb => "FixedPFAbsorb",
            DERControlEnum::FixedPFInject => "FixedPFInject",
            DERControlEnum::FixedVar => "FixedVar",
            DERControlEnum::Gradients => "Gradients",
            DERControlEnum::HFMustTrip => "HFMustTrip",
            DERControlEnum::HFMayTrip => "HFMayTrip",
            DERControlEnum::HVMustTrip => "HVMustTrip",
            DERControlEnum::HVMomCess => "HVMomCess",
            DERControlEnum::HVMayTrip => "HVMayTrip",
            DERControlEnum::LimitMaxDischarge => "LimitMaxDischarge",
            DERControlEnum::LFMustTrip => "LFMustTrip",
            DERControlEnum::LVMustTrip => "LVMustTrip",
            DERControlEnum::LVMomCess => "LVMomCess",
            DERControlEnum::LVMayTrip => "LVMayTrip",
            DERControlEnum::PowerMonitoringMustTrip => "PowerMonitoringMustTrip",
            DERControlEnum::VoltVar => "VoltVar",
            DERControlEnum::VoltWatt => "VoltWatt",
            DERControlEnum::WattPF => "WattPF",
            DERControlEnum::WattVar => "WattVar",
        }
    }
}

impl std::fmt::Display for DERControlEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DERControlEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DERControlEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Result of operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DERControlStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NotSupported")]
    NotSupported,
    #[serde(rename = "NotFound")]
    NotFound,
}

impl DERControlStatusEnum {
    pub const ALL: &'static [DERControlStatusEnum] = &[
        DERControlStatusEnum::Accepted,
        DERControlStatusEnum::Rejected,
        DERControlStatusEnum::NotSupported,
        DERControlStatusEnum::NotFound,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DERControlStatusEnum::Accepted => "Accepted",
            DERControlStatusEnum::Rejected => "Rejected",
            DERControlStatusEnum::NotSupported => "NotSupported",
            DERControlStatusEnum::NotFound => "NotFound",
        }
    }
}

impl std::fmt::Display for DERControlStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DERControlStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DERControlStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Unit of the Y-axis of DER curve
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DERUnitEnum {
    #[serde(rename = "Not_Applicable")]
    NotApplicable,
    #[serde(rename = "PctMaxW")]
    PctMaxW,
    #[serde(rename = "PctMaxVar")]
    PctMaxVar,
    #[serde(rename = "PctWAvail")]
    PctWAvail,
    #[serde(rename = "PctVarAvail")]
    PctVarAvail,
    #[serde(rename = "PctEffectiveV")]
    PctEffectiveV,
}

impl DERUnitEnum {
    pub const ALL: &'static [DERUnitEnum] = &[
        DERUnitEnum::NotApplicable,
        DERUnitEnum::PctMaxW,
        DERUnitEnum::PctMaxVar,
        DERUnitEnum::PctWAvail,
        DERUnitEnum::PctVarAvail,
        DERUnitEnum::PctEffectiveV,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DERUnitEnum::NotApplicable => "Not_Applicable",
            DERUnitEnum::PctMaxW => "PctMaxW",
            DERUnitEnum::PctMaxVar => "PctMaxVar",
            DERUnitEnum::PctWAvail => "PctWAvail",
            DERUnitEnum::PctVarAvail => "PctVarAvail",
            DERUnitEnum::PctEffectiveV => "PctEffectiveV",
        }
    }
}

impl std::fmt::Display for DERUnitEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DERUnitEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DERUnitEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Data type of this variable.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DataEnum {
    #[serde(rename = "string")]
    String,
    #[serde(rename = "decimal")]
    Decimal,
    #[serde(rename = "integer")]
    Integer,
    #[serde(rename = "dateTime")]
    DateTime,
    #[serde(rename = "boolean")]
    Boolean,
    #[serde(rename = "OptionList")]
    OptionList,
    #[serde(rename = "SequenceList")]
    SequenceList,
    #[serde(rename = "MemberList")]
    MemberList,
}

impl DataEnum {
    pub const ALL: &'static [DataEnum] = &[
        DataEnum::String,
        DataEnum::Decimal,
        DataEnum::Integer,
        DataEnum::DateTime,
        DataEnum::Boolean,
        DataEnum::OptionList,
        DataEnum::SequenceList,
        DataEnum::MemberList,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DataEnum::String => "string",
            DataEnum::Decimal => "decimal",
            DataEnum::Integer => "integer",
            DataEnum::DateTime => "dateTime",
            DataEnum::Boolean => "boolean",
            DataEnum::OptionList => "OptionList",
            DataEnum::SequenceList => "SequenceList",
            DataEnum::MemberList => "MemberList",
        }
    }
}

impl std::fmt::Display for DataEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DataEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DataEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates the success or failure of the data transfer.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DataTransferStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "UnknownMessageId")]
    UnknownMessageId,
    #[serde(rename = "UnknownVendorId")]
    UnknownVendorId,
}

impl DataTransferStatusEnum {
    pub const ALL: &'static [DataTransferStatusEnum] = &[
        DataTransferStatusEnum::Accepted,
        DataTransferStatusEnum::Rejected,
        DataTransferStatusEnum::UnknownMessageId,
        DataTransferStatusEnum::UnknownVendorId,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DataTransferStatusEnum::Accepted => "Accepted",
            DataTransferStatusEnum::Rejected => "Rejected",
            DataTransferStatusEnum::UnknownMessageId => "UnknownMessageId",
            DataTransferStatusEnum::UnknownVendorId => "UnknownVendorId",
        }
    }
}

impl std::fmt::Display for DataTransferStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DataTransferStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DataTransferStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DayOfWeekEnum {
    #[serde(rename = "Monday")]
    Monday,
    #[serde(rename = "Tuesday")]
    Tuesday,
    #[serde(rename = "Wednesday")]
    Wednesday,
    #[serde(rename = "Thursday")]
    Thursday,
    #[serde(rename = "Friday")]
    Friday,
    #[serde(rename = "Saturday")]
    Saturday,
    #[serde(rename = "Sunday")]
    Sunday,
}

impl DayOfWeekEnum {
    pub const ALL: &'static [DayOfWeekEnum] = &[
        DayOfWeekEnum::Monday,
        DayOfWeekEnum::Tuesday,
        DayOfWeekEnum::Wednesday,
        DayOfWeekEnum::Thursday,
        DayOfWeekEnum::Friday,
        DayOfWeekEnum::Saturday,
        DayOfWeekEnum::Sunday,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DayOfWeekEnum::Monday => "Monday",
            DayOfWeekEnum::Tuesday => "Tuesday",
            DayOfWeekEnum::Wednesday => "Wednesday",
            DayOfWeekEnum::Thursday => "Thursday",
            DayOfWeekEnum::Friday => "Friday",
            DayOfWeekEnum::Saturday => "Saturday",
            DayOfWeekEnum::Sunday => "Sunday",
        }
    }
}

impl std::fmt::Display for DayOfWeekEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DayOfWeekEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DayOfWeekEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Charging Station indicates if it can process the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DeleteCertificateStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Failed")]
    Failed,
    #[serde(rename = "NotFound")]
    NotFound,
}

impl DeleteCertificateStatusEnum {
    pub const ALL: &'static [DeleteCertificateStatusEnum] = &[
        DeleteCertificateStatusEnum::Accepted,
        DeleteCertificateStatusEnum::Failed,
        DeleteCertificateStatusEnum::NotFound,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DeleteCertificateStatusEnum::Accepted => "Accepted",
            DeleteCertificateStatusEnum::Failed => "Failed",
            DeleteCertificateStatusEnum::NotFound => "NotFound",
        }
    }
}

impl std::fmt::Display for DeleteCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DeleteCertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DeleteCertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station is able to display the message.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DisplayMessageStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "NotSupportedMessageFormat")]
    NotSupportedMessageFormat,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NotSupportedPriority")]
    NotSupportedPriority,
    #[serde(rename = "NotSupportedState")]
    NotSupportedState,
    #[serde(rename = "UnknownTransaction")]
    UnknownTransaction,
    #[serde(rename = "LanguageNotSupported")]
    LanguageNotSupported,
}

impl DisplayMessageStatusEnum {
    pub const ALL: &'static [DisplayMessageStatusEnum] = &[
        DisplayMessageStatusEnum::Accepted,
        DisplayMessageStatusEnum::NotSupportedMessageFormat,
        DisplayMessageStatusEnum::Rejected,
        DisplayMessageStatusEnum::NotSupportedPriority,
        DisplayMessageStatusEnum::NotSupportedState,
        DisplayMessageStatusEnum::UnknownTransaction,
        DisplayMessageStatusEnum::LanguageNotSupported,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            DisplayMessageStatusEnum::Accepted => "Accepted",
            DisplayMessageStatusEnum::NotSupportedMessageFormat => "NotSupportedMessageFormat",
            DisplayMessageStatusEnum::Rejected => "Rejected",
            DisplayMessageStatusEnum::NotSupportedPriority => "NotSupportedPriority",
            DisplayMessageStatusEnum::NotSupportedState => "NotSupportedState",
            DisplayMessageStatusEnum::UnknownTransaction => "UnknownTransaction",
            DisplayMessageStatusEnum::LanguageNotSupported => "LanguageNotSupported",
        }
    }
}

impl std::fmt::Display for DisplayMessageStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for DisplayMessageStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for DisplayMessageStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EnergyTransferModeEnum {
    #[serde(rename = "AC_single_phase")]
    ACSinglePhase,
    #[serde(rename = "AC_two_phase")]
    ACTwoPhase,
    #[serde(rename = "AC_three_phase")]
    ACThreePhase,
    #[serde(rename = "DC")]
    DC,
    #[serde(rename = "AC_BPT")]
    ACBPT,
    #[serde(rename = "AC_BPT_DER")]
    ACBPTDER,
    #[serde(rename = "AC_DER")]
    ACDER,
    #[serde(rename = "DC_BPT")]
    DCBPT,
    #[serde(rename = "DC_ACDP")]
    DCACDP,
    #[serde(rename = "DC_ACDP_BPT")]
    DCACDPBPT,
    #[serde(rename = "WPT")]
    WPT,
}

impl EnergyTransferModeEnum {
    pub const ALL: &'static [EnergyTransferModeEnum] = &[
        EnergyTransferModeEnum::ACSinglePhase,
        EnergyTransferModeEnum::ACTwoPhase,
        EnergyTransferModeEnum::ACThreePhase,
        EnergyTransferModeEnum::DC,
        EnergyTransferModeEnum::ACBPT,
        EnergyTransferModeEnum::ACBPTDER,
        EnergyTransferModeEnum::ACDER,
        EnergyTransferModeEnum::DCBPT,
        EnergyTransferModeEnum::DCACDP,
        EnergyTransferModeEnum::DCACDPBPT,
        EnergyTransferModeEnum::WPT,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            EnergyTransferModeEnum::ACSinglePhase => "AC_single_phase",
            EnergyTransferModeEnum::ACTwoPhase => "AC_two_phase",
            EnergyTransferModeEnum::ACThreePhase => "AC_three_phase",
            EnergyTransferModeEnum::DC => "DC",
            EnergyTransferModeEnum::ACBPT => "AC_BPT",
            EnergyTransferModeEnum::ACBPTDER => "AC_BPT_DER",
            EnergyTransferModeEnum::ACDER => "AC_DER",
            EnergyTransferModeEnum::DCBPT => "DC_BPT",
            EnergyTransferModeEnum::DCACDP => "DC_ACDP",
            EnergyTransferModeEnum::DCACDPBPT => "DC_ACDP_BPT",
            EnergyTransferModeEnum::WPT => "WPT",
        }
    }
}

impl std::fmt::Display for EnergyTransferModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for EnergyTransferModeEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for EnergyTransferModeEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Specifies the event notification type of the message.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EventNotificationEnum {
    #[serde(rename = "HardWiredNotification")]
    HardWiredNotification,
    #[serde(rename = "HardWiredMonitor")]
    HardWiredMonitor,
    #[serde(rename = "PreconfiguredMonitor")]
    PreconfiguredMonitor,
    #[serde(rename = "CustomMonitor")]
    CustomMonitor,
}

impl EventNotificationEnum {
    pub const ALL: &'static [EventNotificationEnum] = &[
        EventNotificationEnum::HardWiredNotification,
        EventNotificationEnum::HardWiredMonitor,
        EventNotificationEnum::PreconfiguredMonitor,
        EventNotificationEnum::CustomMonitor,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            EventNotificationEnum::HardWiredNotification => "HardWiredNotification",
            EventNotificationEnum::HardWiredMonitor => "HardWiredMonitor",
            EventNotificationEnum::PreconfiguredMonitor => "PreconfiguredMonitor",
            EventNotificationEnum::CustomMonitor => "CustomMonitor",
        }
    }
}

impl std::fmt::Display for EventNotificationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for EventNotificationEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for EventNotificationEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of trigger for this event, e.g. exceeding a threshold value.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EventTriggerEnum {
    #[serde(rename = "Alerting")]
    Alerting,
    #[serde(rename = "Delta")]
    Delta,
    #[serde(rename = "Periodic")]
    Periodic,
}

impl EventTriggerEnum {
    pub const ALL: &'static [EventTriggerEnum] = &[
        EventTriggerEnum::Alerting,
        EventTriggerEnum::Delta,
        EventTriggerEnum::Periodic,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            EventTriggerEnum::Alerting => "Alerting",
            EventTriggerEnum::Delta => "Delta",
            EventTriggerEnum::Periodic => "Periodic",
        }
    }
}

impl std::fmt::Display for EventTriggerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for EventTriggerEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for EventTriggerEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of EVSE (AC, DC) this tariff applies to.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EvseKindEnum {
    #[serde(rename = "AC")]
    AC,
    #[serde(rename = "DC")]
    DC,
}

impl EvseKindEnum {
    pub const ALL: &'static [EvseKindEnum] = &[EvseKindEnum::AC, EvseKindEnum::DC];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            EvseKindEnum::AC => "AC",
            EvseKindEnum::DC => "DC",
        }
    }
}

impl std::fmt::Display for EvseKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for EvseKindEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for EvseKindEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the progress status of the firmware installation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum FirmwareStatusEnum {
    #[serde(rename = "Downloaded")]
    Downloaded,
    #[serde(rename = "DownloadFailed")]
    DownloadFailed,
    #[serde(rename = "Downloading")]
    Downloading,
    #[serde(rename = "DownloadScheduled")]
    DownloadScheduled,
    #[serde(rename = "DownloadPaused")]
    DownloadPaused,
    #[serde(rename = "Idle")]
    Idle,
    #[serde(rename = "InstallationFailed")]
    InstallationFailed,
    #[serde(rename = "Installing")]
    Installing,
    #[serde(rename = "Installed")]
    Installed,
    #[serde(rename = "InstallRebooting")]
    InstallRebooting,
    #[serde(rename = "InstallScheduled")]
    InstallScheduled,
    #[serde(rename = "InstallVerificationFailed")]
    InstallVerificationFailed,
    #[serde(rename = "InvalidSignature")]
    InvalidSignature,
    #[serde(rename = "SignatureVerified")]
    SignatureVerified,
}

impl FirmwareStatusEnum {
    pub const ALL: &'static [FirmwareStatusEnum] = &[
        FirmwareStatusEnum::Downloaded,
        FirmwareStatusEnum::DownloadFailed,
        FirmwareStatusEnum::Downloading,
        FirmwareStatusEnum::DownloadScheduled,
        FirmwareStatusEnum::DownloadPaused,
        FirmwareStatusEnum::Idle,
        FirmwareStatusEnum::InstallationFailed,
        FirmwareStatusEnum::Installing,
        FirmwareStatusEnum::Installed,
        FirmwareStatusEnum::InstallRebooting,
        FirmwareStatusEnum::InstallScheduled,
        FirmwareStatusEnum::InstallVerificationFailed,
        FirmwareStatusEnum::InvalidSignature,
        FirmwareStatusEnum::SignatureVerified,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            FirmwareStatusEnum::Downloaded => "Downloaded",
            FirmwareStatusEnum::DownloadFailed => "DownloadFailed",
            FirmwareStatusEnum::Downloading => "Downloading",
            FirmwareStatusEnum::DownloadScheduled => "DownloadScheduled",
            FirmwareStatusEnum::DownloadPaused => "DownloadPaused",
            FirmwareStatusEnum::Idle => "Idle",
            FirmwareStatusEnum::InstallationFailed => "InstallationFailed",
            FirmwareStatusEnum::Installing => "Installing",
            FirmwareStatusEnum::Installed => "Installed",
            FirmwareStatusEnum::InstallRebooting => "InstallRebooting",
            FirmwareStatusEnum::InstallScheduled => "InstallScheduled",
            FirmwareStatusEnum::InstallVerificationFailed => "InstallVerificationFailed",
            FirmwareStatusEnum::InvalidSignature => "InvalidSignature",
            FirmwareStatusEnum::SignatureVerified => "SignatureVerified",
        }
    }
}

impl std::fmt::Display for FirmwareStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for FirmwareStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for FirmwareStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station is able to accept this request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GenericDeviceModelStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NotSupported")]
    NotSupported,
    #[serde(rename = "EmptyResultSet")]
    EmptyResultSet,
}

impl GenericDeviceModelStatusEnum {
    pub const ALL: &'static [GenericDeviceModelStatusEnum] = &[
        GenericDeviceModelStatusEnum::Accepted,
        GenericDeviceModelStatusEnum::Rejected,
        GenericDeviceModelStatusEnum::NotSupported,
        GenericDeviceModelStatusEnum::EmptyResultSet,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GenericDeviceModelStatusEnum::Accepted => "Accepted",
            GenericDeviceModelStatusEnum::Rejected => "Rejected",
            GenericDeviceModelStatusEnum::NotSupported => "NotSupported",
            GenericDeviceModelStatusEnum::EmptyResultSet => "EmptyResultSet",
        }
    }
}

impl std::fmt::Display for GenericDeviceModelStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GenericDeviceModelStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GenericDeviceModelStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GenericStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl GenericStatusEnum {
    pub const ALL: &'static [GenericStatusEnum] =
        &[GenericStatusEnum::Accepted, GenericStatusEnum::Rejected];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GenericStatusEnum::Accepted => "Accepted",
            GenericStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for GenericStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GenericStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GenericStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GetCertificateIdUseEnum {
    #[serde(rename = "V2GRootCertificate")]
    V2GRootCertificate,
    #[serde(rename = "MORootCertificate")]
    MORootCertificate,
    #[serde(rename = "CSMSRootCertificate")]
    CSMSRootCertificate,
    #[serde(rename = "V2GCertificateChain")]
    V2GCertificateChain,
    #[serde(rename = "ManufacturerRootCertificate")]
    ManufacturerRootCertificate,
    #[serde(rename = "OEMRootCertificate")]
    OEMRootCertificate,
}

impl GetCertificateIdUseEnum {
    pub const ALL: &'static [GetCertificateIdUseEnum] = &[
        GetCertificateIdUseEnum::V2GRootCertificate,
        GetCertificateIdUseEnum::MORootCertificate,
        GetCertificateIdUseEnum::CSMSRootCertificate,
        GetCertificateIdUseEnum::V2GCertificateChain,
        GetCertificateIdUseEnum::ManufacturerRootCertificate,
        GetCertificateIdUseEnum::OEMRootCertificate,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GetCertificateIdUseEnum::V2GRootCertificate => "V2GRootCertificate",
            GetCertificateIdUseEnum::MORootCertificate => "MORootCertificate",
            GetCertificateIdUseEnum::CSMSRootCertificate => "CSMSRootCertificate",
            GetCertificateIdUseEnum::V2GCertificateChain => "V2GCertificateChain",
            GetCertificateIdUseEnum::ManufacturerRootCertificate => "ManufacturerRootCertificate",
            GetCertificateIdUseEnum::OEMRootCertificate => "OEMRootCertificate",
        }
    }
}

impl std::fmt::Display for GetCertificateIdUseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GetCertificateIdUseEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GetCertificateIdUseEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the charging station was able to retrieve the OCSP certificate status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GetCertificateStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Failed")]
    Failed,
}

impl GetCertificateStatusEnum {
    pub const ALL: &'static [GetCertificateStatusEnum] = &[
        GetCertificateStatusEnum::Accepted,
        GetCertificateStatusEnum::Failed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GetCertificateStatusEnum::Accepted => "Accepted",
            GetCertificateStatusEnum::Failed => "Failed",
        }
    }
}

impl std::fmt::Display for GetCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GetCertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GetCertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station is able to process this request and will send &lt;&lt;reportchargingprofilesrequest, ReportChargingProfilesRequest&gt;&gt; messages.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GetChargingProfileStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "NoProfiles")]
    NoProfiles,
}

impl GetChargingProfileStatusEnum {
    pub const ALL: &'static [GetChargingProfileStatusEnum] = &[
        GetChargingProfileStatusEnum::Accepted,
        GetChargingProfileStatusEnum::NoProfiles,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GetChargingProfileStatusEnum::Accepted => "Accepted",
            GetChargingProfileStatusEnum::NoProfiles => "NoProfiles",
        }
    }
}

impl std::fmt::Display for GetChargingProfileStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GetChargingProfileStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GetChargingProfileStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates if the Charging Station has Display Messages that match the request criteria in the &lt;&lt;getdisplaymessagesrequest,GetDisplayMessagesRequest&gt;&gt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GetDisplayMessagesStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Unknown")]
    Unknown,
}

impl GetDisplayMessagesStatusEnum {
    pub const ALL: &'static [GetDisplayMessagesStatusEnum] = &[
        GetDisplayMessagesStatusEnum::Accepted,
        GetDisplayMessagesStatusEnum::Unknown,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GetDisplayMessagesStatusEnum::Accepted => "Accepted",
            GetDisplayMessagesStatusEnum::Unknown => "Unknown",
        }
    }
}

impl std::fmt::Display for GetDisplayMessagesStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GetDisplayMessagesStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GetDisplayMessagesStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Charging Station indicates if it can process the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GetInstalledCertificateStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "NotFound")]
    NotFound,
}

impl GetInstalledCertificateStatusEnum {
    pub const ALL: &'static [GetInstalledCertificateStatusEnum] = &[
        GetInstalledCertificateStatusEnum::Accepted,
        GetInstalledCertificateStatusEnum::NotFound,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GetInstalledCertificateStatusEnum::Accepted => "Accepted",
            GetInstalledCertificateStatusEnum::NotFound => "NotFound",
        }
    }
}

impl std::fmt::Display for GetInstalledCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GetInstalledCertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GetInstalledCertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GetVariableStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "UnknownComponent")]
    UnknownComponent,
    #[serde(rename = "UnknownVariable")]
    UnknownVariable,
    #[serde(rename = "NotSupportedAttributeType")]
    NotSupportedAttributeType,
}

impl GetVariableStatusEnum {
    pub const ALL: &'static [GetVariableStatusEnum] = &[
        GetVariableStatusEnum::Accepted,
        GetVariableStatusEnum::Rejected,
        GetVariableStatusEnum::UnknownComponent,
        GetVariableStatusEnum::UnknownVariable,
        GetVariableStatusEnum::NotSupportedAttributeType,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GetVariableStatusEnum::Accepted => "Accepted",
            GetVariableStatusEnum::Rejected => "Rejected",
            GetVariableStatusEnum::UnknownComponent => "UnknownComponent",
            GetVariableStatusEnum::UnknownVariable => "UnknownVariable",
            GetVariableStatusEnum::NotSupportedAttributeType => "NotSupportedAttributeType",
        }
    }
}

impl std::fmt::Display for GetVariableStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GetVariableStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GetVariableStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of grid event that caused this
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GridEventFaultEnum {
    #[serde(rename = "CurrentImbalance")]
    CurrentImbalance,
    #[serde(rename = "LocalEmergency")]
    LocalEmergency,
    #[serde(rename = "LowInputPower")]
    LowInputPower,
    #[serde(rename = "OverCurrent")]
    OverCurrent,
    #[serde(rename = "OverFrequency")]
    OverFrequency,
    #[serde(rename = "OverVoltage")]
    OverVoltage,
    #[serde(rename = "PhaseRotation")]
    PhaseRotation,
    #[serde(rename = "RemoteEmergency")]
    RemoteEmergency,
    #[serde(rename = "UnderFrequency")]
    UnderFrequency,
    #[serde(rename = "UnderVoltage")]
    UnderVoltage,
    #[serde(rename = "VoltageImbalance")]
    VoltageImbalance,
}

impl GridEventFaultEnum {
    pub const ALL: &'static [GridEventFaultEnum] = &[
        GridEventFaultEnum::CurrentImbalance,
        GridEventFaultEnum::LocalEmergency,
        GridEventFaultEnum::LowInputPower,
        GridEventFaultEnum::OverCurrent,
        GridEventFaultEnum::OverFrequency,
        GridEventFaultEnum::OverVoltage,
        GridEventFaultEnum::PhaseRotation,
        GridEventFaultEnum::RemoteEmergency,
        GridEventFaultEnum::UnderFrequency,
        GridEventFaultEnum::UnderVoltage,
        GridEventFaultEnum::VoltageImbalance,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            GridEventFaultEnum::CurrentImbalance => "CurrentImbalance",
            GridEventFaultEnum::LocalEmergency => "LocalEmergency",
            GridEventFaultEnum::LowInputPower => "LowInputPower",
            GridEventFaultEnum::OverCurrent => "OverCurrent",
            GridEventFaultEnum::OverFrequency => "OverFrequency",
            GridEventFaultEnum::OverVoltage => "OverVoltage",
            GridEventFaultEnum::PhaseRotation => "PhaseRotation",
            GridEventFaultEnum::RemoteEmergency => "RemoteEmergency",
            GridEventFaultEnum::UnderFrequency => "UnderFrequency",
            GridEventFaultEnum::UnderVoltage => "UnderVoltage",
            GridEventFaultEnum::VoltageImbalance => "VoltageImbalance",
        }
    }
}

impl std::fmt::Display for GridEventFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for GridEventFaultEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for GridEventFaultEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Used algorithms for the hashes provided.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum HashAlgorithmEnum {
    #[serde(rename = "SHA256")]
    SHA256,
    #[serde(rename = "SHA384")]
    SHA384,
    #[serde(rename = "SHA512")]
    SHA512,
}

impl HashAlgorithmEnum {
    pub const ALL: &'static [HashAlgorithmEnum] = &[
        HashAlgorithmEnum::SHA256,
        HashAlgorithmEnum::SHA384,
        HashAlgorithmEnum::SHA512,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            HashAlgorithmEnum::SHA256 => "SHA256",
            HashAlgorithmEnum::SHA384 => "SHA384",
            HashAlgorithmEnum::SHA512 => "SHA512",
        }
    }
}

impl std::fmt::Display for HashAlgorithmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for HashAlgorithmEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for HashAlgorithmEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Charging Station indicates if installation was successful.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InstallCertificateStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Failed")]
    Failed,
}

impl InstallCertificateStatusEnum {
    pub const ALL: &'static [InstallCertificateStatusEnum] = &[
        InstallCertificateStatusEnum::Accepted,
        InstallCertificateStatusEnum::Rejected,
        InstallCertificateStatusEnum::Failed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            InstallCertificateStatusEnum::Accepted => "Accepted",
            InstallCertificateStatusEnum::Rejected => "Rejected",
            InstallCertificateStatusEnum::Failed => "Failed",
        }
    }
}

impl std::fmt::Display for InstallCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for InstallCertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for InstallCertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates the certificate type that is sent.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum InstallCertificateUseEnum {
    #[serde(rename = "V2GRootCertificate")]
    V2GRootCertificate,
    #[serde(rename = "MORootCertificate")]
    MORootCertificate,
    #[serde(rename = "ManufacturerRootCertificate")]
    ManufacturerRootCertificate,
    #[serde(rename = "CSMSRootCertificate")]
    CSMSRootCertificate,
    #[serde(rename = "OEMRootCertificate")]
    OEMRootCertificate,
}

impl InstallCertificateUseEnum {
    pub const ALL: &'static [InstallCertificateUseEnum] = &[
        InstallCertificateUseEnum::V2GRootCertificate,
        InstallCertificateUseEnum::MORootCertificate,
        InstallCertificateUseEnum::ManufacturerRootCertificate,
        InstallCertificateUseEnum::CSMSRootCertificate,
        InstallCertificateUseEnum::OEMRootCertificate,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            InstallCertificateUseEnum::V2GRootCertificate => "V2GRootCertificate",
            InstallCertificateUseEnum::MORootCertificate => "MORootCertificate",
            InstallCertificateUseEnum::ManufacturerRootCertificate => "ManufacturerRootCertificate",
            InstallCertificateUseEnum::CSMSRootCertificate => "CSMSRootCertificate",
            InstallCertificateUseEnum::OEMRootCertificate => "OEMRootCertificate",
        }
    }
}

impl std::fmt::Display for InstallCertificateUseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for InstallCertificateUseEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for InstallCertificateUseEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum IslandingDetectionEnum {
    #[serde(rename = "NoAntiIslandingSupport")]
    NoAntiIslandingSupport,
    #[serde(rename = "RoCoF")]
    RoCoF,
    #[serde(rename = "UVP_OVP")]
    UVPOVP,
    #[serde(rename = "UFP_OFP")]
    UFPOFP,
    #[serde(rename = "VoltageVectorShift")]
    VoltageVectorShift,
    #[serde(rename = "ZeroCrossingDetection")]
    ZeroCrossingDetection,
    #[serde(rename = "OtherPassive")]
    OtherPassive,
    #[serde(rename = "ImpedanceMeasurement")]
    ImpedanceMeasurement,
    #[serde(rename = "ImpedanceAtFrequency")]
    ImpedanceAtFrequency,
    #[serde(rename = "SlipModeFrequencyShift")]
    SlipModeFrequencyShift,
    #[serde(rename = "SandiaFrequencyShift")]
    SandiaFrequencyShift,
    #[serde(rename = "SandiaVoltageShift")]
    SandiaVoltageShift,
    #[serde(rename = "FrequencyJump")]
    FrequencyJump,
    #[serde(rename = "RCLQFactor")]
    RCLQFactor,
    #[serde(rename = "OtherActive")]
    OtherActive,
}

impl IslandingDetectionEnum {
    pub const ALL: &'static [IslandingDetectionEnum] = &[
        IslandingDetectionEnum::NoAntiIslandingSupport,
        IslandingDetectionEnum::RoCoF,
        IslandingDetectionEnum::UVPOVP,
        IslandingDetectionEnum::UFPOFP,
        IslandingDetectionEnum::VoltageVectorShift,
        IslandingDetectionEnum::ZeroCrossingDetection,
        IslandingDetectionEnum::OtherPassive,
        IslandingDetectionEnum::ImpedanceMeasurement,
        IslandingDetectionEnum::ImpedanceAtFrequency,
        IslandingDetectionEnum::SlipModeFrequencyShift,
        IslandingDetectionEnum::SandiaFrequencyShift,
        IslandingDetectionEnum::SandiaVoltageShift,
        IslandingDetectionEnum::FrequencyJump,
        IslandingDetectionEnum::RCLQFactor,
        IslandingDetectionEnum::OtherActive,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            IslandingDetectionEnum::NoAntiIslandingSupport => "NoAntiIslandingSupport",
            IslandingDetectionEnum::RoCoF => "RoCoF",
            IslandingDetectionEnum::UVPOVP => "UVP_OVP",
            IslandingDetectionEnum::UFPOFP => "UFP_OFP",
            IslandingDetectionEnum::VoltageVectorShift => "VoltageVectorShift",
            IslandingDetectionEnum::ZeroCrossingDetection => "ZeroCrossingDetection",
            IslandingDetectionEnum::OtherPassive => "OtherPassive",
            IslandingDetectionEnum::ImpedanceMeasurement => "ImpedanceMeasurement",
            IslandingDetectionEnum::ImpedanceAtFrequency => "ImpedanceAtFrequency",
            IslandingDetectionEnum::SlipModeFrequencyShift => "SlipModeFrequencyShift",
            IslandingDetectionEnum::SandiaFrequencyShift => "SandiaFrequencyShift",
            IslandingDetectionEnum::SandiaVoltageShift => "SandiaVoltageShift",
            IslandingDetectionEnum::FrequencyJump => "FrequencyJump",
            IslandingDetectionEnum::RCLQFactor => "RCLQFactor",
            IslandingDetectionEnum::OtherActive => "OtherActive",
        }
    }
}

impl std::fmt::Display for IslandingDetectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for IslandingDetectionEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for IslandingDetectionEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates whether the message was processed properly.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Iso15118EVCertificateStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Failed")]
    Failed,
}

impl Iso15118EVCertificateStatusEnum {
    pub const ALL: &'static [Iso15118EVCertificateStatusEnum] = &[
        Iso15118EVCertificateStatusEnum::Accepted,
        Iso15118EVCertificateStatusEnum::Failed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            Iso15118EVCertificateStatusEnum::Accepted => "Accepted",
            Iso15118EVCertificateStatusEnum::Failed => "Failed",
        }
    }
}

impl std::fmt::Display for Iso15118EVCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for Iso15118EVCertificateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for Iso15118EVCertificateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates where the measured value has been sampled. Default =  "Outlet"
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum LocationEnum {
    #[serde(rename = "Body")]
    Body,
    #[serde(rename = "Cable")]
    Cable,
    #[serde(rename = "EV")]
    EV,
    #[serde(rename = "Inlet")]
    Inlet,
    #[serde(rename = "Outlet")]
    Outlet,
    #[serde(rename = "Upstream")]
    Upstream,
}

impl LocationEnum {
    pub const ALL: &'static [LocationEnum] = &[
        LocationEnum::Body,
        LocationEnum::Cable,
        LocationEnum::EV,
        LocationEnum::Inlet,
        LocationEnum::Outlet,
        LocationEnum::Upstream,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            LocationEnum::Body => "Body",
            LocationEnum::Cable => "Cable",
            LocationEnum::EV => "EV",
            LocationEnum::Inlet => "Inlet",
            LocationEnum::Outlet => "Outlet",
            LocationEnum::Upstream => "Upstream",
        }
    }
}

impl std::fmt::Display for LocationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for LocationEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for LocationEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the type of log file that the Charging Station
/// should send.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum LogEnum {
    #[serde(rename = "DiagnosticsLog")]
    DiagnosticsLog,
    #[serde(rename = "SecurityLog")]
    SecurityLog,
    #[serde(rename = "DataCollectorLog")]
    DataCollectorLog,
}

impl LogEnum {
    pub const ALL: &'static [LogEnum] = &[
        LogEnum::DiagnosticsLog,
        LogEnum::SecurityLog,
        LogEnum::DataCollectorLog,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            LogEnum::DiagnosticsLog => "DiagnosticsLog",
            LogEnum::SecurityLog => "SecurityLog",
            LogEnum::DataCollectorLog => "DataCollectorLog",
        }
    }
}

impl std::fmt::Display for LogEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for LogEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for LogEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This field indicates whether the Charging Station was able to accept the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum LogStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "AcceptedCanceled")]
    AcceptedCanceled,
}

impl LogStatusEnum {
    pub const ALL: &'static [LogStatusEnum] = &[
        LogStatusEnum::Accepted,
        LogStatusEnum::Rejected,
        LogStatusEnum::AcceptedCanceled,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            LogStatusEnum::Accepted => "Accepted",
            LogStatusEnum::Rejected => "Rejected",
            LogStatusEnum::AcceptedCanceled => "AcceptedCanceled",
        }
    }
}

impl std::fmt::Display for LogStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for LogStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for LogStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of measurement. Default = "Energy.Active.Import.Register"
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MeasurandEnum {
    #[serde(rename = "Current.Export")]
    CurrentExport,
    #[serde(rename = "Current.Export.Offered")]
    CurrentExportOffered,
    #[serde(rename = "Current.Export.Minimum")]
    CurrentExportMinimum,
    #[serde(rename = "Current.Import")]
    CurrentImport,
    #[serde(rename = "Current.Import.Offered")]
    CurrentImportOffered,
    #[serde(rename = "Current.Import.Minimum")]
    CurrentImportMinimum,
    #[serde(rename = "Current.Offered")]
    CurrentOffered,
    #[serde(rename = "Display.PresentSOC")]
    DisplayPresentSOC,
    #[serde(rename = "Display.MinimumSOC")]
    DisplayMinimumSOC,
    #[serde(rename = "Display.TargetSOC")]
    DisplayTargetSOC,
    #[serde(rename = "Display.MaximumSOC")]
    DisplayMaximumSOC,
    #[serde(rename = "Display.RemainingTimeToMinimumSOC")]
    DisplayRemainingTimeToMinimumSOC,
    #[serde(rename = "Display.RemainingTimeToTargetSOC")]
    DisplayRemainingTimeToTargetSOC,
    #[serde(rename = "Display.RemainingTimeToMaximumSOC")]
    DisplayRemainingTimeToMaximumSOC,
    #[serde(rename = "Display.ChargingComplete")]
    DisplayChargingComplete,
    #[serde(rename = "Display.BatteryEnergyCapacity")]
    DisplayBatteryEnergyCapacity,
    #[serde(rename = "Display.InletHot")]
    DisplayInletHot,
    #[serde(rename = "Energy.Active.Export.Interval")]
    EnergyActiveExportInterval,
    #[serde(rename = "Energy.Active.Export.Register")]
    EnergyActiveExportRegister,
    #[serde(rename = "Energy.Active.Import.Interval")]
    EnergyActiveImportInterval,
    #[serde(rename = "Energy.Active.Import.Register")]
    EnergyActiveImportRegister,
    #[serde(rename = "Energy.Active.Import.CableLoss")]
    EnergyActiveImportCableLoss,
    #[serde(rename = "Energy.Active.Import.LocalGeneration.Register")]
    EnergyActiveImportLocalGenerationRegister,
    #[serde(rename = "Energy.Active.Net")]
    EnergyActiveNet,
    #[serde(rename = "Energy.Active.Setpoint.Interval")]
    EnergyActiveSetpointInterval,
    #[serde(rename = "Energy.Apparent.Export")]
    EnergyApparentExport,
    #[serde(rename = "Energy.Apparent.Import")]
    EnergyApparentImport,
    #[serde(rename = "Energy.Apparent.Net")]
    EnergyApparentNet,
    #[serde(rename = "Energy.Reactive.Export.Interval")]
    EnergyReactiveExportInterval,
    #[serde(rename = "Energy.Reactive.Export.Register")]
    EnergyReactiveExportRegister,
    #[serde(rename = "Energy.Reactive.Import.Interval")]
    EnergyReactiveImportInterval,
    #[serde(rename = "Energy.Reactive.Import.Register")]
    EnergyReactiveImportRegister,
    #[serde(rename = "Energy.Reactive.Net")]
    EnergyReactiveNet,
    #[serde(rename = "EnergyRequest.Target")]
    EnergyRequestTarget,
    #[serde(rename = "EnergyRequest.Minimum")]
    EnergyRequestMinimum,
    #[serde(rename = "EnergyRequest.Maximum")]
    EnergyRequestMaximum,
    #[serde(rename = "EnergyRequest.Minimum.V2X")]
    EnergyRequestMinimumV2X,
    #[serde(rename = "EnergyRequest.Maximum.V2X")]
    EnergyRequestMaximumV2X,
    #[serde(rename = "EnergyRequest.Bulk")]
    EnergyRequestBulk,
    #[serde(rename = "Frequency")]
    Frequency,
    #[serde(rename = "Power.Active.Export")]
    PowerActiveExport,
    #[serde(rename = "Power.Active.Import")]
    PowerActiveImport,
    #[serde(rename = "Power.Active.Setpoint")]
    PowerActiveSetpoint,
    #[serde(rename = "Power.Active.Residual")]
    PowerActiveResidual,
    #[serde(rename = "Power.Export.Minimum")]
    PowerExportMinimum,
    #[serde(rename = "Power.Export.Offered")]
    PowerExportOffered,
    #[serde(rename = "Power.Factor")]
    PowerFactor,
    #[serde(rename = "Power.Import.Offered")]
    PowerImportOffered,
    #[serde(rename = "Power.Import.Minimum")]
    PowerImportMinimum,
    #[serde(rename = "Power.Offered")]
    PowerOffered,
    #[serde(rename = "Power.Reactive.Export")]
    PowerReactiveExport,
    #[serde(rename = "Power.Reactive.Import")]
    PowerReactiveImport,
    #[serde(rename = "SoC")]
    SoC,
    #[serde(rename = "Voltage")]
    Voltage,
    #[serde(rename = "Voltage.Minimum")]
    VoltageMinimum,
    #[serde(rename = "Voltage.Maximum")]
    VoltageMaximum,
}

impl MeasurandEnum {
    pub const ALL: &'static [MeasurandEnum] = &[
        MeasurandEnum::CurrentExport,
        MeasurandEnum::CurrentExportOffered,
        MeasurandEnum::CurrentExportMinimum,
        MeasurandEnum::CurrentImport,
        MeasurandEnum::CurrentImportOffered,
        MeasurandEnum::CurrentImportMinimum,
        MeasurandEnum::CurrentOffered,
        MeasurandEnum::DisplayPresentSOC,
        MeasurandEnum::DisplayMinimumSOC,
        MeasurandEnum::DisplayTargetSOC,
        MeasurandEnum::DisplayMaximumSOC,
        MeasurandEnum::DisplayRemainingTimeToMinimumSOC,
        MeasurandEnum::DisplayRemainingTimeToTargetSOC,
        MeasurandEnum::DisplayRemainingTimeToMaximumSOC,
        MeasurandEnum::DisplayChargingComplete,
        MeasurandEnum::DisplayBatteryEnergyCapacity,
        MeasurandEnum::DisplayInletHot,
        MeasurandEnum::EnergyActiveExportInterval,
        MeasurandEnum::EnergyActiveExportRegister,
        MeasurandEnum::EnergyActiveImportInterval,
        MeasurandEnum::EnergyActiveImportRegister,
        MeasurandEnum::EnergyActiveImportCableLoss,
        MeasurandEnum::EnergyActiveImportLocalGenerationRegister,
        MeasurandEnum::EnergyActiveNet,
        MeasurandEnum::EnergyActiveSetpointInterval,
        MeasurandEnum::EnergyApparentExport,
        MeasurandEnum::EnergyApparentImport,
        MeasurandEnum::EnergyApparentNet,
        MeasurandEnum::EnergyReactiveExportInterval,
        MeasurandEnum::EnergyReactiveExportRegister,
        MeasurandEnum::EnergyReactiveImportInterval,
        MeasurandEnum::EnergyReactiveImportRegister,
        MeasurandEnum::EnergyReactiveNet,
        MeasurandEnum::EnergyRequestTarget,
        MeasurandEnum::EnergyRequestMinimum,
        MeasurandEnum::EnergyRequestMaximum,
        MeasurandEnum::EnergyRequestMinimumV2X,
        MeasurandEnum::EnergyRequestMaximumV2X,
        MeasurandEnum::EnergyRequestBulk,
        MeasurandEnum::Frequency,
        MeasurandEnum::PowerActiveExport,
        MeasurandEnum::PowerActiveImport,
        MeasurandEnum::PowerActiveSetpoint,
        MeasurandEnum::PowerActiveResidual,
        MeasurandEnum::PowerExportMinimum,
        MeasurandEnum::PowerExportOffered,
        MeasurandEnum::PowerFactor,
        MeasurandEnum::PowerImportOffered,
        MeasurandEnum::PowerImportMinimum,
        MeasurandEnum::PowerOffered,
        MeasurandEnum::PowerReactiveExport,
        MeasurandEnum::PowerReactiveImport,
        MeasurandEnum::SoC,
        MeasurandEnum::Voltage,
        MeasurandEnum::VoltageMinimum,
        MeasurandEnum::VoltageMaximum,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MeasurandEnum::CurrentExport => "Current.Export",
            MeasurandEnum::CurrentExportOffered => "Current.Export.Offered",
            MeasurandEnum::CurrentExportMinimum => "Current.Export.Minimum",
            MeasurandEnum::CurrentImport => "Current.Import",
            MeasurandEnum::CurrentImportOffered => "Current.Import.Offered",
            MeasurandEnum::CurrentImportMinimum => "Current.Import.Minimum",
            MeasurandEnum::CurrentOffered => "Current.Offered",
            MeasurandEnum::DisplayPresentSOC => "Display.PresentSOC",
            MeasurandEnum::DisplayMinimumSOC => "Display.MinimumSOC",
            MeasurandEnum::DisplayTargetSOC => "Display.TargetSOC",
            MeasurandEnum::DisplayMaximumSOC => "Display.MaximumSOC",
            MeasurandEnum::DisplayRemainingTimeToMinimumSOC => "Display.RemainingTimeToMinimumSOC",
            MeasurandEnum::DisplayRemainingTimeToTargetSOC => "Display.RemainingTimeToTargetSOC",
            MeasurandEnum::DisplayRemainingTimeToMaximumSOC => "Display.RemainingTimeToMaximumSOC",
            MeasurandEnum::DisplayChargingComplete => "Display.ChargingComplete",
            MeasurandEnum::DisplayBatteryEnergyCapacity => "Display.BatteryEnergyCapacity",
            MeasurandEnum::DisplayInletHot => "Display.InletHot",
            MeasurandEnum::EnergyActiveExportInterval => "Energy.Active.Export.Interval",
            MeasurandEnum::EnergyActiveExportRegister => "Energy.Active.Export.Register",
            MeasurandEnum::EnergyActiveImportInterval => "Energy.Active.Import.Interval",
            MeasurandEnum::EnergyActiveImportRegister => "Energy.Active.Import.Register",
            MeasurandEnum::EnergyActiveImportCableLoss => "Energy.Active.Import.CableLoss",
            MeasurandEnum::EnergyActiveImportLocalGenerationRegister => {
                "Energy.Active.Import.LocalGeneration.Register"
            }
            MeasurandEnum::EnergyActiveNet => "Energy.Active.Net",
            MeasurandEnum::EnergyActiveSetpointInterval => "Energy.Active.Setpoint.Interval",
            MeasurandEnum::EnergyApparentExport => "Energy.Apparent.Export",
            MeasurandEnum::EnergyApparentImport => "Energy.Apparent.Import",
            MeasurandEnum::EnergyApparentNet => "Energy.Apparent.Net",
            MeasurandEnum::EnergyReactiveExportInterval => "Energy.Reactive.Export.Interval",
            MeasurandEnum::EnergyReactiveExportRegister => "Energy.Reactive.Export.Register",
            MeasurandEnum::EnergyReactiveImportInterval => "Energy.Reactive.Import.Interval",
            MeasurandEnum::EnergyReactiveImportRegister => "Energy.Reactive.Import.Register",
            MeasurandEnum::EnergyReactiveNet => "Energy.Reactive.Net",
            MeasurandEnum::EnergyRequestTarget => "EnergyRequest.Target",
            MeasurandEnum::EnergyRequestMinimum => "EnergyRequest.Minimum",
            MeasurandEnum::EnergyRequestMaximum => "EnergyRequest.Maximum",
            MeasurandEnum::EnergyRequestMinimumV2X => "EnergyRequest.Minimum.V2X",
            MeasurandEnum::EnergyRequestMaximumV2X => "EnergyRequest.Maximum.V2X",
            MeasurandEnum::EnergyRequestBulk => "EnergyRequest.Bulk",
            MeasurandEnum::Frequency => "Frequency",
            MeasurandEnum::PowerActiveExport => "Power.Active.Export",
            MeasurandEnum::PowerActiveImport => "Power.Active.Import",
            MeasurandEnum::PowerActiveSetpoint => "Power.Active.Setpoint",
            MeasurandEnum::PowerActiveResidual => "Power.Active.Residual",
            MeasurandEnum::PowerExportMinimum => "Power.Export.Minimum",
            MeasurandEnum::PowerExportOffered => "Power.Export.Offered",
            MeasurandEnum::PowerFactor => "Power.Factor",
            MeasurandEnum::PowerImportOffered => "Power.Import.Offered",
            MeasurandEnum::PowerImportMinimum => "Power.Import.Minimum",
            MeasurandEnum::PowerOffered => "Power.Offered",
            MeasurandEnum::PowerReactiveExport => "Power.Reactive.Export",
            MeasurandEnum::PowerReactiveImport => "Power.Reactive.Import",
            MeasurandEnum::SoC => "SoC",
            MeasurandEnum::Voltage => "Voltage",
            MeasurandEnum::VoltageMinimum => "Voltage.Minimum",
            MeasurandEnum::VoltageMaximum => "Voltage.Maximum",
        }
    }
}

impl std::fmt::Display for MeasurandEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MeasurandEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MeasurandEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Format of the message.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MessageFormatEnum {
    #[serde(rename = "ASCII")]
    ASCII,
    #[serde(rename = "HTML")]
    HTML,
    #[serde(rename = "URI")]
    URI,
    #[serde(rename = "UTF8")]
    UTF8,
    #[serde(rename = "QRCODE")]
    QRCODE,
}

impl MessageFormatEnum {
    pub const ALL: &'static [MessageFormatEnum] = &[
        MessageFormatEnum::ASCII,
        MessageFormatEnum::HTML,
        MessageFormatEnum::URI,
        MessageFormatEnum::UTF8,
        MessageFormatEnum::QRCODE,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MessageFormatEnum::ASCII => "ASCII",
            MessageFormatEnum::HTML => "HTML",
            MessageFormatEnum::URI => "URI",
            MessageFormatEnum::UTF8 => "UTF8",
            MessageFormatEnum::QRCODE => "QRCODE",
        }
    }
}

impl std::fmt::Display for MessageFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MessageFormatEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MessageFormatEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// If provided the Charging Station shall return Display Messages with the given priority only.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MessagePriorityEnum {
    #[serde(rename = "AlwaysFront")]
    AlwaysFront,
    #[serde(rename = "InFront")]
    InFront,
    #[serde(rename = "NormalCycle")]
    NormalCycle,
}

impl MessagePriorityEnum {
    pub const ALL: &'static [MessagePriorityEnum] = &[
        MessagePriorityEnum::AlwaysFront,
        MessagePriorityEnum::InFront,
        MessagePriorityEnum::NormalCycle,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MessagePriorityEnum::AlwaysFront => "AlwaysFront",
            MessagePriorityEnum::InFront => "InFront",
            MessagePriorityEnum::NormalCycle => "NormalCycle",
        }
    }
}

impl std::fmt::Display for MessagePriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MessagePriorityEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MessagePriorityEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// If provided the Charging Station shall return Display Messages with the given state only.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MessageStateEnum {
    #[serde(rename = "Charging")]
    Charging,
    #[serde(rename = "Faulted")]
    Faulted,
    #[serde(rename = "Idle")]
    Idle,
    #[serde(rename = "Unavailable")]
    Unavailable,
    #[serde(rename = "Suspended")]
    Suspended,
    #[serde(rename = "Discharging")]
    Discharging,
}

impl MessageStateEnum {
    pub const ALL: &'static [MessageStateEnum] = &[
        MessageStateEnum::Charging,
        MessageStateEnum::Faulted,
        MessageStateEnum::Idle,
        MessageStateEnum::Unavailable,
        MessageStateEnum::Suspended,
        MessageStateEnum::Discharging,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MessageStateEnum::Charging => "Charging",
            MessageStateEnum::Faulted => "Faulted",
            MessageStateEnum::Idle => "Idle",
            MessageStateEnum::Unavailable => "Unavailable",
            MessageStateEnum::Suspended => "Suspended",
            MessageStateEnum::Discharging => "Discharging",
        }
    }
}

impl std::fmt::Display for MessageStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MessageStateEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MessageStateEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of message to be triggered.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MessageTriggerEnum {
    #[serde(rename = "BootNotification")]
    BootNotification,
    #[serde(rename = "LogStatusNotification")]
    LogStatusNotification,
    #[serde(rename = "FirmwareStatusNotification")]
    FirmwareStatusNotification,
    #[serde(rename = "Heartbeat")]
    Heartbeat,
    #[serde(rename = "MeterValues")]
    MeterValues,
    #[serde(rename = "SignChargingStationCertificate")]
    SignChargingStationCertificate,
    #[serde(rename = "SignV2GCertificate")]
    SignV2GCertificate,
    #[serde(rename = "SignV2G20Certificate")]
    SignV2G20Certificate,
    #[serde(rename = "StatusNotification")]
    StatusNotification,
    #[serde(rename = "TransactionEvent")]
    TransactionEvent,
    #[serde(rename = "SignCombinedCertificate")]
    SignCombinedCertificate,
    #[serde(rename = "PublishFirmwareStatusNotification")]
    PublishFirmwareStatusNotification,
    #[serde(rename = "CustomTrigger")]
    CustomTrigger,
}

impl MessageTriggerEnum {
    pub const ALL: &'static [MessageTriggerEnum] = &[
        MessageTriggerEnum::BootNotification,
        MessageTriggerEnum::LogStatusNotification,
        MessageTriggerEnum::FirmwareStatusNotification,
        MessageTriggerEnum::Heartbeat,
        MessageTriggerEnum::MeterValues,
        MessageTriggerEnum::SignChargingStationCertificate,
        MessageTriggerEnum::SignV2GCertificate,
        MessageTriggerEnum::SignV2G20Certificate,
        MessageTriggerEnum::StatusNotification,
        MessageTriggerEnum::TransactionEvent,
        MessageTriggerEnum::SignCombinedCertificate,
        MessageTriggerEnum::PublishFirmwareStatusNotification,
        MessageTriggerEnum::CustomTrigger,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MessageTriggerEnum::BootNotification => "BootNotification",
            MessageTriggerEnum::LogStatusNotification => "LogStatusNotification",
            MessageTriggerEnum::FirmwareStatusNotification => "FirmwareStatusNotification",
            MessageTriggerEnum::Heartbeat => "Heartbeat",
            MessageTriggerEnum::MeterValues => "MeterValues",
            MessageTriggerEnum::SignChargingStationCertificate => "SignChargingStationCertificate",
            MessageTriggerEnum::SignV2GCertificate => "SignV2GCertificate",
            MessageTriggerEnum::SignV2G20Certificate => "SignV2G20Certificate",
            MessageTriggerEnum::StatusNotification => "StatusNotification",
            MessageTriggerEnum::TransactionEvent => "TransactionEvent",
            MessageTriggerEnum::SignCombinedCertificate => "SignCombinedCertificate",
            MessageTriggerEnum::PublishFirmwareStatusNotification => {
                "PublishFirmwareStatusNotification"
            }
            MessageTriggerEnum::CustomTrigger => "CustomTrigger",
        }
    }
}

impl std::fmt::Display for MessageTriggerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MessageTriggerEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MessageTriggerEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// *(2.1)* Value of EVCC indicates that EV determines min/target SOC and departure time. +
/// A value of EVCC_SECC indicates that charging station or CSMS may also update min/target SOC and departure time. +
/// *ISO 15118-20:* +
/// ServiceSelectionReq(SelectedEnergyTransferService)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MobilityNeedsModeEnum {
    #[serde(rename = "EVCC")]
    EVCC,
    #[serde(rename = "EVCC_SECC")]
    EVCCSECC,
}

impl MobilityNeedsModeEnum {
    pub const ALL: &'static [MobilityNeedsModeEnum] =
        &[MobilityNeedsModeEnum::EVCC, MobilityNeedsModeEnum::EVCCSECC];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MobilityNeedsModeEnum::EVCC => "EVCC",
            MobilityNeedsModeEnum::EVCCSECC => "EVCC_SECC",
        }
    }
}

impl std::fmt::Display for MobilityNeedsModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MobilityNeedsModeEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MobilityNeedsModeEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// The type of this monitor, e.g. a threshold, delta or periodic monitor.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MonitorEnum {
    #[serde(rename = "UpperThreshold")]
    UpperThreshold,
    #[serde(rename = "LowerThreshold")]
    LowerThreshold,
    #[serde(rename = "Delta")]
    Delta,
    #[serde(rename = "Periodic")]
    Periodic,
    #[serde(rename = "PeriodicClockAligned")]
    PeriodicClockAligned,
    #[serde(rename = "TargetDelta")]
    TargetDelta,
    #[serde(rename = "TargetDeltaRelative")]
    TargetDeltaRelative,
}

impl MonitorEnum {
    pub const ALL: &'static [MonitorEnum] = &[
        MonitorEnum::UpperThreshold,
        MonitorEnum::LowerThreshold,
        MonitorEnum::Delta,
        MonitorEnum::Periodic,
        MonitorEnum::PeriodicClockAligned,
        MonitorEnum::TargetDelta,
        MonitorEnum::TargetDeltaRelative,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MonitorEnum::UpperThreshold => "UpperThreshold",
            MonitorEnum::LowerThreshold => "LowerThreshold",
            MonitorEnum::Delta => "Delta",
            MonitorEnum::Periodic => "Periodic",
            MonitorEnum::PeriodicClockAligned => "PeriodicClockAligned",
            MonitorEnum::TargetDelta => "TargetDelta",
            MonitorEnum::TargetDeltaRelative => "TargetDeltaRelative",
        }
    }
}

impl std::fmt::Display for MonitorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MonitorEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MonitorEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Specify which monitoring base will be set
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MonitoringBaseEnum {
    #[serde(rename = "All")]
    All,
    #[serde(rename = "FactoryDefault")]
    FactoryDefault,
    #[serde(rename = "HardWiredOnly")]
    HardWiredOnly,
}

impl MonitoringBaseEnum {
    pub const ALL: &'static [MonitoringBaseEnum] = &[
        MonitoringBaseEnum::All,
        MonitoringBaseEnum::FactoryDefault,
        MonitoringBaseEnum::HardWiredOnly,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MonitoringBaseEnum::All => "All",
            MonitoringBaseEnum::FactoryDefault => "FactoryDefault",
            MonitoringBaseEnum::HardWiredOnly => "HardWiredOnly",
        }
    }
}

impl std::fmt::Display for MonitoringBaseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MonitoringBaseEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MonitoringBaseEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MonitoringCriterionEnum {
    #[serde(rename = "ThresholdMonitoring")]
    ThresholdMonitoring,
    #[serde(rename = "DeltaMonitoring")]
    DeltaMonitoring,
    #[serde(rename = "PeriodicMonitoring")]
    PeriodicMonitoring,
}

impl MonitoringCriterionEnum {
    pub const ALL: &'static [MonitoringCriterionEnum] = &[
        MonitoringCriterionEnum::ThresholdMonitoring,
        MonitoringCriterionEnum::DeltaMonitoring,
        MonitoringCriterionEnum::PeriodicMonitoring,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MonitoringCriterionEnum::ThresholdMonitoring => "ThresholdMonitoring",
            MonitoringCriterionEnum::DeltaMonitoring => "DeltaMonitoring",
            MonitoringCriterionEnum::PeriodicMonitoring => "PeriodicMonitoring",
        }
    }
}

impl std::fmt::Display for MonitoringCriterionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MonitoringCriterionEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MonitoringCriterionEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Defines the mutability of this attribute. Default is ReadWrite when omitted.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MutabilityEnum {
    #[serde(rename = "ReadOnly")]
    ReadOnly,
    #[serde(rename = "WriteOnly")]
    WriteOnly,
    #[serde(rename = "ReadWrite")]
    ReadWrite,
}

impl MutabilityEnum {
    pub const ALL: &'static [MutabilityEnum] = &[
        MutabilityEnum::ReadOnly,
        MutabilityEnum::WriteOnly,
        MutabilityEnum::ReadWrite,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MutabilityEnum::ReadOnly => "ReadOnly",
            MutabilityEnum::WriteOnly => "WriteOnly",
            MutabilityEnum::ReadWrite => "ReadWrite",
        }
    }
}

impl std::fmt::Display for MutabilityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for MutabilityEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for MutabilityEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum NotifyAllowedEnergyTransferStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl NotifyAllowedEnergyTransferStatusEnum {
    pub const ALL: &'static [NotifyAllowedEnergyTransferStatusEnum] = &[
        NotifyAllowedEnergyTransferStatusEnum::Accepted,
        NotifyAllowedEnergyTransferStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            NotifyAllowedEnergyTransferStatusEnum::Accepted => "Accepted",
            NotifyAllowedEnergyTransferStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for NotifyAllowedEnergyTransferStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for NotifyAllowedEnergyTransferStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for NotifyAllowedEnergyTransferStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Returns whether the CSMS has been able to process the message successfully. It does not imply that the evChargingNeeds can be met with the current charging profile.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum NotifyEVChargingNeedsStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Processing")]
    Processing,
    #[serde(rename = "NoChargingProfile")]
    NoChargingProfile,
}

impl NotifyEVChargingNeedsStatusEnum {
    pub const ALL: &'static [NotifyEVChargingNeedsStatusEnum] = &[
        NotifyEVChargingNeedsStatusEnum::Accepted,
        NotifyEVChargingNeedsStatusEnum::Rejected,
        NotifyEVChargingNeedsStatusEnum::Processing,
        NotifyEVChargingNeedsStatusEnum::NoChargingProfile,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            NotifyEVChargingNeedsStatusEnum::Accepted => "Accepted",
            NotifyEVChargingNeedsStatusEnum::Rejected => "Rejected",
            NotifyEVChargingNeedsStatusEnum::Processing => "Processing",
            NotifyEVChargingNeedsStatusEnum::NoChargingProfile => "NoChargingProfile",
        }
    }
}

impl std::fmt::Display for NotifyEVChargingNeedsStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for NotifyEVChargingNeedsStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for NotifyEVChargingNeedsStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Applicable Network Interface. Charging Station is allowed to use a different network interface to connect if the given one does not work.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OCPPInterfaceEnum {
    #[serde(rename = "Wired0")]
    Wired0,
    #[serde(rename = "Wired1")]
    Wired1,
    #[serde(rename = "Wired2")]
    Wired2,
    #[serde(rename = "Wired3")]
    Wired3,
    #[serde(rename = "Wireless0")]
    Wireless0,
    #[serde(rename = "Wireless1")]
    Wireless1,
    #[serde(rename = "Wireless2")]
    Wireless2,
    #[serde(rename = "Wireless3")]
    Wireless3,
    #[serde(rename = "Any")]
    Any,
}

impl OCPPInterfaceEnum {
    pub const ALL: &'static [OCPPInterfaceEnum] = &[
        OCPPInterfaceEnum::Wired0,
        OCPPInterfaceEnum::Wired1,
        OCPPInterfaceEnum::Wired2,
        OCPPInterfaceEnum::Wired3,
        OCPPInterfaceEnum::Wireless0,
        OCPPInterfaceEnum::Wireless1,
        OCPPInterfaceEnum::Wireless2,
        OCPPInterfaceEnum::Wireless3,
        OCPPInterfaceEnum::Any,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            OCPPInterfaceEnum::Wired0 => "Wired0",
            OCPPInterfaceEnum::Wired1 => "Wired1",
            OCPPInterfaceEnum::Wired2 => "Wired2",
            OCPPInterfaceEnum::Wired3 => "Wired3",
            OCPPInterfaceEnum::Wireless0 => "Wireless0",
            OCPPInterfaceEnum::Wireless1 => "Wireless1",
            OCPPInterfaceEnum::Wireless2 => "Wireless2",
            OCPPInterfaceEnum::Wireless3 => "Wireless3",
            OCPPInterfaceEnum::Any => "Any",
        }
    }
}

impl std::fmt::Display for OCPPInterfaceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for OCPPInterfaceEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for OCPPInterfaceEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Defines the transport protocol (e.g. SOAP or JSON). Note: SOAP is not supported in OCPP 2.x, but is supported by earlier versions of OCPP.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OCPPTransportEnum {
    #[serde(rename = "SOAP")]
    SOAP,
    #[serde(rename = "JSON")]
    JSON,
}

impl OCPPTransportEnum {
    pub const ALL: &'static [OCPPTransportEnum] =
        &[OCPPTransportEnum::SOAP, OCPPTransportEnum::JSON];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            OCPPTransportEnum::SOAP => "SOAP",
            OCPPTransportEnum::JSON => "JSON",
        }
    }
}

impl std::fmt::Display for OCPPTransportEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for OCPPTransportEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for OCPPTransportEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// *(2.1)* This field is ignored, since the OCPP version to use is determined during the websocket handshake. The field is only kept for backwards compatibility with the OCPP 2.0.1 JSON schema.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OCPPVersionEnum {
    #[serde(rename = "OCPP12")]
    OCPP12,
    #[serde(rename = "OCPP15")]
    OCPP15,
    #[serde(rename = "OCPP16")]
    OCPP16,
    #[serde(rename = "OCPP20")]
    OCPP20,
    #[serde(rename = "OCPP201")]
    OCPP201,
    #[serde(rename = "OCPP21")]
    OCPP21,
}

impl OCPPVersionEnum {
    pub const ALL: &'static [OCPPVersionEnum] = &[
        OCPPVersionEnum::OCPP12,
        OCPPVersionEnum::OCPP15,
        OCPPVersionEnum::OCPP16,
        OCPPVersionEnum::OCPP20,
        OCPPVersionEnum::OCPP201,
        OCPPVersionEnum::OCPP21,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            OCPPVersionEnum::OCPP12 => "OCPP12",
            OCPPVersionEnum::OCPP15 => "OCPP15",
            OCPPVersionEnum::OCPP16 => "OCPP16",
            OCPPVersionEnum::OCPP20 => "OCPP20",
            OCPPVersionEnum::OCPP201 => "OCPP201",
            OCPPVersionEnum::OCPP21 => "OCPP21",
        }
    }
}

impl std::fmt::Display for OCPPVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for OCPPVersionEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for OCPPVersionEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// *(2.1)* Charging operation mode to use during this time interval. When absent defaults to `ChargingOnly`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OperationModeEnum {
    #[serde(rename = "Idle")]
    Idle,
    #[serde(rename = "ChargingOnly")]
    ChargingOnly,
    #[serde(rename = "CentralSetpoint")]
    CentralSetpoint,
    #[serde(rename = "ExternalSetpoint")]
    ExternalSetpoint,
    #[serde(rename = "ExternalLimits")]
    ExternalLimits,
    #[serde(rename = "CentralFrequency")]
    CentralFrequency,
    #[serde(rename = "LocalFrequency")]
    LocalFrequency,
    #[serde(rename = "LocalLoadBalancing")]
    LocalLoadBalancing,
}

impl OperationModeEnum {
    pub const ALL: &'static [OperationModeEnum] = &[
        OperationModeEnum::Idle,
        OperationModeEnum::ChargingOnly,
        OperationModeEnum::CentralSetpoint,
        OperationModeEnum::ExternalSetpoint,
        OperationModeEnum::ExternalLimits,
        OperationModeEnum::CentralFrequency,
        OperationModeEnum::LocalFrequency,
        OperationModeEnum::LocalLoadBalancing,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            OperationModeEnum::Idle => "Idle",
            OperationModeEnum::ChargingOnly => "ChargingOnly",
            OperationModeEnum::CentralSetpoint => "CentralSetpoint",
            OperationModeEnum::ExternalSetpoint => "ExternalSetpoint",
            OperationModeEnum::ExternalLimits => "ExternalLimits",
            OperationModeEnum::CentralFrequency => "CentralFrequency",
            OperationModeEnum::LocalFrequency => "LocalFrequency",
            OperationModeEnum::LocalLoadBalancing => "LocalLoadBalancing",
        }
    }
}

impl std::fmt::Display for OperationModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for OperationModeEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for OperationModeEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the type of availability change that the Charging Station should perform.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OperationalStatusEnum {
    #[serde(rename = "Inoperative")]
    Inoperative,
    #[serde(rename = "Operative")]
    Operative,
}

impl OperationalStatusEnum {
    pub const ALL: &'static [OperationalStatusEnum] = &[
        OperationalStatusEnum::Inoperative,
        OperationalStatusEnum::Operative,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            OperationalStatusEnum::Inoperative => "Inoperative",
            OperationalStatusEnum::Operative => "Operative",
        }
    }
}

impl std::fmt::Display for OperationalStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for OperationalStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for OperationalStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// The status of the settlement attempt.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PaymentStatusEnum {
    #[serde(rename = "Settled")]
    Settled,
    #[serde(rename = "Canceled")]
    Canceled,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Failed")]
    Failed,
}

impl PaymentStatusEnum {
    pub const ALL: &'static [PaymentStatusEnum] = &[
        PaymentStatusEnum::Settled,
        PaymentStatusEnum::Canceled,
        PaymentStatusEnum::Rejected,
        PaymentStatusEnum::Failed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            PaymentStatusEnum::Settled => "Settled",
            PaymentStatusEnum::Canceled => "Canceled",
            PaymentStatusEnum::Rejected => "Rejected",
            PaymentStatusEnum::Failed => "Failed",
        }
    }
}

impl std::fmt::Display for PaymentStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for PaymentStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for PaymentStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates how the measured value is to be interpreted. For instance between L1 and neutral (L1-N) Please note that not all values of phase are applicable to all Measurands. When phase is absent, the measured value is interpreted as an overall value.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PhaseEnum {
    #[serde(rename = "L1")]
    L1,
    #[serde(rename = "L2")]
    L2,
    #[serde(rename = "L3")]
    L3,
    #[serde(rename = "N")]
    N,
    #[serde(rename = "L1-N")]
    L1N,
    #[serde(rename = "L2-N")]
    L2N,
    #[serde(rename = "L3-N")]
    L3N,
    #[serde(rename = "L1-L2")]
    L1L2,
    #[serde(rename = "L2-L3")]
    L2L3,
    #[serde(rename = "L3-L1")]
    L3L1,
}

impl PhaseEnum {
    pub const ALL: &'static [PhaseEnum] = &[
        PhaseEnum::L1,
        PhaseEnum::L2,
        PhaseEnum::L3,
        PhaseEnum::N,
        PhaseEnum::L1N,
        PhaseEnum::L2N,
        PhaseEnum::L3N,
        PhaseEnum::L1L2,
        PhaseEnum::L2L3,
        PhaseEnum::L3L1,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            PhaseEnum::L1 => "L1",
            PhaseEnum::L2 => "L2",
            PhaseEnum::L3 => "L3",
            PhaseEnum::N => "N",
            PhaseEnum::L1N => "L1-N",
            PhaseEnum::L2N => "L2-N",
            PhaseEnum::L3N => "L3-N",
            PhaseEnum::L1L2 => "L1-L2",
            PhaseEnum::L2L3 => "L2-L3",
            PhaseEnum::L3L1 => "L3-L1",
        }
    }
}

impl std::fmt::Display for PhaseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for PhaseEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for PhaseEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Parameter is only sent, if the EV has to feed-in power or reactive power during fault-ride through (FRT) as defined by HVMomCess curve and LVMomCess curve.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PowerDuringCessationEnum {
    #[serde(rename = "Active")]
    Active,
    #[serde(rename = "Reactive")]
    Reactive,
}

impl PowerDuringCessationEnum {
    pub const ALL: &'static [PowerDuringCessationEnum] = &[
        PowerDuringCessationEnum::Active,
        PowerDuringCessationEnum::Reactive,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            PowerDuringCessationEnum::Active => "Active",
            PowerDuringCessationEnum::Reactive => "Reactive",
        }
    }
}

impl std::fmt::Display for PowerDuringCessationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for PowerDuringCessationEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for PowerDuringCessationEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// *(2.1)* The current preconditioning status of the BMS in the EV. Default value is Unknown.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PreconditioningStatusEnum {
    #[serde(rename = "Unknown")]
    Unknown,
    #[serde(rename = "Ready")]
    Ready,
    #[serde(rename = "NotReady")]
    NotReady,
    #[serde(rename = "Preconditioning")]
    Preconditioning,
}

impl PreconditioningStatusEnum {
    pub const ALL: &'static [PreconditioningStatusEnum] = &[
        PreconditioningStatusEnum::Unknown,
        PreconditioningStatusEnum::Ready,
        PreconditioningStatusEnum::NotReady,
        PreconditioningStatusEnum::Preconditioning,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            PreconditioningStatusEnum::Unknown => "Unknown",
            PreconditioningStatusEnum::Ready => "Ready",
            PreconditioningStatusEnum::NotReady => "NotReady",
            PreconditioningStatusEnum::Preconditioning => "Preconditioning",
        }
    }
}

impl std::fmt::Display for PreconditioningStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for PreconditioningStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for PreconditioningStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Result of the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PriorityChargingStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NoProfile")]
    NoProfile,
}

impl PriorityChargingStatusEnum {
    pub const ALL: &'static [PriorityChargingStatusEnum] = &[
        PriorityChargingStatusEnum::Accepted,
        PriorityChargingStatusEnum::Rejected,
        PriorityChargingStatusEnum::NoProfile,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            PriorityChargingStatusEnum::Accepted => "Accepted",
            PriorityChargingStatusEnum::Rejected => "Rejected",
            PriorityChargingStatusEnum::NoProfile => "NoProfile",
        }
    }
}

impl std::fmt::Display for PriorityChargingStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for PriorityChargingStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for PriorityChargingStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the progress status of the publishfirmware
/// installation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PublishFirmwareStatusEnum {
    #[serde(rename = "Idle")]
    Idle,
    #[serde(rename = "DownloadScheduled")]
    DownloadScheduled,
    #[serde(rename = "Downloading")]
    Downloading,
    #[serde(rename = "Downloaded")]
    Downloaded,
    #[serde(rename = "Published")]
    Published,
    #[serde(rename = "DownloadFailed")]
    DownloadFailed,
    #[serde(rename = "DownloadPaused")]
    DownloadPaused,
    #[serde(rename = "InvalidChecksum")]
    InvalidChecksum,
    #[serde(rename = "ChecksumVerified")]
    ChecksumVerified,
    #[serde(rename = "PublishFailed")]
    PublishFailed,
}

impl PublishFirmwareStatusEnum {
    pub const ALL: &'static [PublishFirmwareStatusEnum] = &[
        PublishFirmwareStatusEnum::Idle,
        PublishFirmwareStatusEnum::DownloadScheduled,
        PublishFirmwareStatusEnum::Downloading,
        PublishFirmwareStatusEnum::Downloaded,
        PublishFirmwareStatusEnum::Published,
        PublishFirmwareStatusEnum::DownloadFailed,
        PublishFirmwareStatusEnum::DownloadPaused,
        PublishFirmwareStatusEnum::InvalidChecksum,
        PublishFirmwareStatusEnum::ChecksumVerified,
        PublishFirmwareStatusEnum::PublishFailed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            PublishFirmwareStatusEnum::Idle => "Idle",
            PublishFirmwareStatusEnum::DownloadScheduled => "DownloadScheduled",
            PublishFirmwareStatusEnum::Downloading => "Downloading",
            PublishFirmwareStatusEnum::Downloaded => "Downloaded",
            PublishFirmwareStatusEnum::Published => "Published",
            PublishFirmwareStatusEnum::DownloadFailed => "DownloadFailed",
            PublishFirmwareStatusEnum::DownloadPaused => "DownloadPaused",
            PublishFirmwareStatusEnum::InvalidChecksum => "InvalidChecksum",
            PublishFirmwareStatusEnum::ChecksumVerified => "ChecksumVerified",
            PublishFirmwareStatusEnum::PublishFailed => "PublishFailed",
        }
    }
}

impl std::fmt::Display for PublishFirmwareStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for PublishFirmwareStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for PublishFirmwareStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of detail value: start, end or sample. Default = "Sample.Periodic"
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ReadingContextEnum {
    #[serde(rename = "Interruption.Begin")]
    InterruptionBegin,
    #[serde(rename = "Interruption.End")]
    InterruptionEnd,
    #[serde(rename = "Other")]
    Other,
    #[serde(rename = "Sample.Clock")]
    SampleClock,
    #[serde(rename = "Sample.Periodic")]
    SamplePeriodic,
    #[serde(rename = "Transaction.Begin")]
    TransactionBegin,
    #[serde(rename = "Transaction.End")]
    TransactionEnd,
    #[serde(rename = "Trigger")]
    Trigger,
}

impl ReadingContextEnum {
    pub const ALL: &'static [ReadingContextEnum] = &[
        ReadingContextEnum::InterruptionBegin,
        ReadingContextEnum::InterruptionEnd,
        ReadingContextEnum::Other,
        ReadingContextEnum::SampleClock,
        ReadingContextEnum::SamplePeriodic,
        ReadingContextEnum::TransactionBegin,
        ReadingContextEnum::TransactionEnd,
        ReadingContextEnum::Trigger,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ReadingContextEnum::InterruptionBegin => "Interruption.Begin",
            ReadingContextEnum::InterruptionEnd => "Interruption.End",
            ReadingContextEnum::Other => "Other",
            ReadingContextEnum::SampleClock => "Sample.Clock",
            ReadingContextEnum::SamplePeriodic => "Sample.Periodic",
            ReadingContextEnum::TransactionBegin => "Transaction.Begin",
            ReadingContextEnum::TransactionEnd => "Transaction.End",
            ReadingContextEnum::Trigger => "Trigger",
        }
    }
}

impl std::fmt::Display for ReadingContextEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ReadingContextEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ReadingContextEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// The _stoppedReason_ is the reason/event that initiated the process of stopping the transaction. It will normally be the user stopping authorization via card (Local or MasterPass) or app (Remote), but it can also be CSMS revoking authorization (DeAuthorized), or disconnecting the EV when TxStopPoint = EVConnected (EVDisconnected). Most other reasons are related to technical faults or energy limitations. +
/// MAY only be omitted when _stoppedReason_ is "Local"
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ReasonEnum {
    #[serde(rename = "DeAuthorized")]
    DeAuthorized,
    #[serde(rename = "EmergencyStop")]
    EmergencyStop,
    #[serde(rename = "EnergyLimitReached")]
    EnergyLimitReached,
    #[serde(rename = "EVDisconnected")]
    EVDisconnected,
    #[serde(rename = "GroundFault")]
    GroundFault,
    #[serde(rename = "ImmediateReset")]
    ImmediateReset,
    #[serde(rename = "MasterPass")]
    MasterPass,
    #[serde(rename = "Local")]
    Local,
    #[serde(rename = "LocalOutOfCredit")]
    LocalOutOfCredit,
    #[serde(rename = "Other")]
    Other,
    #[serde(rename = "OvercurrentFault")]
    OvercurrentFault,
    #[serde(rename = "PowerLoss")]
    PowerLoss,
    #[serde(rename = "PowerQuality")]
    PowerQuality,
    #[serde(rename = "Reboot")]
    Reboot,
    #[serde(rename = "Remote")]
    Remote,
    #[serde(rename = "SOCLimitReached")]
    SOCLimitReached,
    #[serde(rename = "StoppedByEV")]
    StoppedByEV,
    #[serde(rename = "TimeLimitReached")]
    TimeLimitReached,
    #[serde(rename = "Timeout")]
    Timeout,
    #[serde(rename = "ReqEnergyTransferRejected")]
    ReqEnergyTransferRejected,
}

impl ReasonEnum {
    pub const ALL: &'static [ReasonEnum] = &[
        ReasonEnum::DeAuthorized,
        ReasonEnum::EmergencyStop,
        ReasonEnum::EnergyLimitReached,
        ReasonEnum::EVDisconnected,
        ReasonEnum::GroundFault,
        ReasonEnum::ImmediateReset,
        ReasonEnum::MasterPass,
        ReasonEnum::Local,
        ReasonEnum::LocalOutOfCredit,
        ReasonEnum::Other,
        ReasonEnum::OvercurrentFault,
        ReasonEnum::PowerLoss,
        ReasonEnum::PowerQuality,
        ReasonEnum::Reboot,
        ReasonEnum::Remote,
        ReasonEnum::SOCLimitReached,
        ReasonEnum::StoppedByEV,
        ReasonEnum::TimeLimitReached,
        ReasonEnum::Timeout,
        ReasonEnum::ReqEnergyTransferRejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ReasonEnum::DeAuthorized => "DeAuthorized",
            ReasonEnum::EmergencyStop => "EmergencyStop",
            ReasonEnum::EnergyLimitReached => "EnergyLimitReached",
            ReasonEnum::EVDisconnected => "EVDisconnected",
            ReasonEnum::GroundFault => "GroundFault",
            ReasonEnum::ImmediateReset => "ImmediateReset",
            ReasonEnum::MasterPass => "MasterPass",
            ReasonEnum::Local => "Local",
            ReasonEnum::LocalOutOfCredit => "LocalOutOfCredit",
            ReasonEnum::Other => "Other",
            ReasonEnum::OvercurrentFault => "OvercurrentFault",
            ReasonEnum::PowerLoss => "PowerLoss",
            ReasonEnum::PowerQuality => "PowerQuality",
            ReasonEnum::Reboot => "Reboot",
            ReasonEnum::Remote => "Remote",
            ReasonEnum::SOCLimitReached => "SOCLimitReached",
            ReasonEnum::StoppedByEV => "StoppedByEV",
            ReasonEnum::TimeLimitReached => "TimeLimitReached",
            ReasonEnum::Timeout => "Timeout",
            ReasonEnum::ReqEnergyTransferRejected => "ReqEnergyTransferRejected",
        }
    }
}

impl std::fmt::Display for ReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ReasonEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ReasonEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates the start point of a recurrence.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum RecurrencyKindEnum {
    #[serde(rename = "Daily")]
    Daily,
    #[serde(rename = "Weekly")]
    Weekly,
}

impl RecurrencyKindEnum {
    pub const ALL: &'static [RecurrencyKindEnum] =
        &[RecurrencyKindEnum::Daily, RecurrencyKindEnum::Weekly];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            RecurrencyKindEnum::Daily => "Daily",
            RecurrencyKindEnum::Weekly => "Weekly",
        }
    }
}

impl std::fmt::Display for RecurrencyKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for RecurrencyKindEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for RecurrencyKindEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains whether the Charging Station has been registered
/// within the CSMS.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum RegistrationStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Pending")]
    Pending,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl RegistrationStatusEnum {
    pub const ALL: &'static [RegistrationStatusEnum] = &[
        RegistrationStatusEnum::Accepted,
        RegistrationStatusEnum::Pending,
        RegistrationStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            RegistrationStatusEnum::Accepted => "Accepted",
            RegistrationStatusEnum::Pending => "Pending",
            RegistrationStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for RegistrationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for RegistrationStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for RegistrationStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This field specifies the report base.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ReportBaseEnum {
    #[serde(rename = "ConfigurationInventory")]
    ConfigurationInventory,
    #[serde(rename = "FullInventory")]
    FullInventory,
    #[serde(rename = "SummaryInventory")]
    SummaryInventory,
}

impl ReportBaseEnum {
    pub const ALL: &'static [ReportBaseEnum] = &[
        ReportBaseEnum::ConfigurationInventory,
        ReportBaseEnum::FullInventory,
        ReportBaseEnum::SummaryInventory,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ReportBaseEnum::ConfigurationInventory => "ConfigurationInventory",
            ReportBaseEnum::FullInventory => "FullInventory",
            ReportBaseEnum::SummaryInventory => "SummaryInventory",
        }
    }
}

impl std::fmt::Display for ReportBaseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ReportBaseEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ReportBaseEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Status indicating whether the Charging Station accepts the request to start a transaction.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum RequestStartStopStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
}

impl RequestStartStopStatusEnum {
    pub const ALL: &'static [RequestStartStopStatusEnum] = &[
        RequestStartStopStatusEnum::Accepted,
        RequestStartStopStatusEnum::Rejected,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            RequestStartStopStatusEnum::Accepted => "Accepted",
            RequestStartStopStatusEnum::Rejected => "Rejected",
        }
    }
}

impl std::fmt::Display for RequestStartStopStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for RequestStartStopStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for RequestStartStopStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// The updated reservation status.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ReservationUpdateStatusEnum {
    #[serde(rename = "Expired")]
    Expired,
    #[serde(rename = "Removed")]
    Removed,
    #[serde(rename = "NoTransaction")]
    NoTransaction,
}

impl ReservationUpdateStatusEnum {
    pub const ALL: &'static [ReservationUpdateStatusEnum] = &[
        ReservationUpdateStatusEnum::Expired,
        ReservationUpdateStatusEnum::Removed,
        ReservationUpdateStatusEnum::NoTransaction,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ReservationUpdateStatusEnum::Expired => "Expired",
            ReservationUpdateStatusEnum::Removed => "Removed",
            ReservationUpdateStatusEnum::NoTransaction => "NoTransaction",
        }
    }
}

impl std::fmt::Display for ReservationUpdateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ReservationUpdateStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ReservationUpdateStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates the success or failure of the reservation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ReserveNowStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Faulted")]
    Faulted,
    #[serde(rename = "Occupied")]
    Occupied,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Unavailable")]
    Unavailable,
}

impl ReserveNowStatusEnum {
    pub const ALL: &'static [ReserveNowStatusEnum] = &[
        ReserveNowStatusEnum::Accepted,
        ReserveNowStatusEnum::Faulted,
        ReserveNowStatusEnum::Occupied,
        ReserveNowStatusEnum::Rejected,
        ReserveNowStatusEnum::Unavailable,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ReserveNowStatusEnum::Accepted => "Accepted",
            ReserveNowStatusEnum::Faulted => "Faulted",
            ReserveNowStatusEnum::Occupied => "Occupied",
            ReserveNowStatusEnum::Rejected => "Rejected",
            ReserveNowStatusEnum::Unavailable => "Unavailable",
        }
    }
}

impl std::fmt::Display for ReserveNowStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ReserveNowStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ReserveNowStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the type of reset that the Charging Station or EVSE should perform.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ResetEnum {
    #[serde(rename = "Immediate")]
    Immediate,
    #[serde(rename = "OnIdle")]
    OnIdle,
    #[serde(rename = "ImmediateAndResume")]
    ImmediateAndResume,
}

impl ResetEnum {
    pub const ALL: &'static [ResetEnum] = &[
        ResetEnum::Immediate,
        ResetEnum::OnIdle,
        ResetEnum::ImmediateAndResume,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ResetEnum::Immediate => "Immediate",
            ResetEnum::OnIdle => "OnIdle",
            ResetEnum::ImmediateAndResume => "ImmediateAndResume",
        }
    }
}

impl std::fmt::Display for ResetEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ResetEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ResetEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station is able to perform the reset.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ResetStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Scheduled")]
    Scheduled,
}

impl ResetStatusEnum {
    pub const ALL: &'static [ResetStatusEnum] = &[
        ResetStatusEnum::Accepted,
        ResetStatusEnum::Rejected,
        ResetStatusEnum::Scheduled,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ResetStatusEnum::Accepted => "Accepted",
            ResetStatusEnum::Rejected => "Rejected",
            ResetStatusEnum::Scheduled => "Scheduled",
        }
    }
}

impl std::fmt::Display for ResetStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for ResetStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for ResetStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station has successfully received and applied the update of the Local Authorization List.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum SendLocalListStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Failed")]
    Failed,
    #[serde(rename = "VersionMismatch")]
    VersionMismatch,
}

impl SendLocalListStatusEnum {
    pub const ALL: &'static [SendLocalListStatusEnum] = &[
        SendLocalListStatusEnum::Accepted,
        SendLocalListStatusEnum::Failed,
        SendLocalListStatusEnum::VersionMismatch,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            SendLocalListStatusEnum::Accepted => "Accepted",
            SendLocalListStatusEnum::Failed => "Failed",
            SendLocalListStatusEnum::VersionMismatch => "VersionMismatch",
        }
    }
}

impl std::fmt::Display for SendLocalListStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for SendLocalListStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for SendLocalListStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Status is OK if a value could be returned. Otherwise this will indicate the reason why a value could not be returned.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum SetMonitoringStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "UnknownComponent")]
    UnknownComponent,
    #[serde(rename = "UnknownVariable")]
    UnknownVariable,
    #[serde(rename = "UnsupportedMonitorType")]
    UnsupportedMonitorType,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Duplicate")]
    Duplicate,
}

impl SetMonitoringStatusEnum {
    pub const ALL: &'static [SetMonitoringStatusEnum] = &[
        SetMonitoringStatusEnum::Accepted,
        SetMonitoringStatusEnum::UnknownComponent,
        SetMonitoringStatusEnum::UnknownVariable,
        SetMonitoringStatusEnum::UnsupportedMonitorType,
        SetMonitoringStatusEnum::Rejected,
        SetMonitoringStatusEnum::Duplicate,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            SetMonitoringStatusEnum::Accepted => "Accepted",
            SetMonitoringStatusEnum::UnknownComponent => "UnknownComponent",
            SetMonitoringStatusEnum::UnknownVariable => "UnknownVariable",
            SetMonitoringStatusEnum::UnsupportedMonitorType => "UnsupportedMonitorType",
            SetMonitoringStatusEnum::Rejected => "Rejected",
            SetMonitoringStatusEnum::Duplicate => "Duplicate",
        }
    }
}

impl std::fmt::Display for SetMonitoringStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for SetMonitoringStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for SetMonitoringStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Result of operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum SetNetworkProfileStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "Failed")]
    Failed,
}

impl SetNetworkProfileStatusEnum {
    pub const ALL: &'static [SetNetworkProfileStatusEnum] = &[
        SetNetworkProfileStatusEnum::Accepted,
        SetNetworkProfileStatusEnum::Rejected,
        SetNetworkProfileStatusEnum::Failed,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            SetNetworkProfileStatusEnum::Accepted => "Accepted",
            SetNetworkProfileStatusEnum::Rejected => "Rejected",
            SetNetworkProfileStatusEnum::Failed => "Failed",
        }
    }
}

impl std::fmt::Display for SetNetworkProfileStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for SetNetworkProfileStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for SetNetworkProfileStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Result status of setting the variable.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum SetVariableStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "UnknownComponent")]
    UnknownComponent,
    #[serde(rename = "UnknownVariable")]
    UnknownVariable,
    #[serde(rename = "NotSupportedAttributeType")]
    NotSupportedAttributeType,
    #[serde(rename = "RebootRequired")]
    RebootRequired,
}

impl SetVariableStatusEnum {
    pub const ALL: &'static [SetVariableStatusEnum] = &[
        SetVariableStatusEnum::Accepted,
        SetVariableStatusEnum::Rejected,
        SetVariableStatusEnum::UnknownComponent,
        SetVariableStatusEnum::UnknownVariable,
        SetVariableStatusEnum::NotSupportedAttributeType,
        SetVariableStatusEnum::RebootRequired,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            SetVariableStatusEnum::Accepted => "Accepted",
            SetVariableStatusEnum::Rejected => "Rejected",
            SetVariableStatusEnum::UnknownComponent => "UnknownComponent",
            SetVariableStatusEnum::UnknownVariable => "UnknownVariable",
            SetVariableStatusEnum::NotSupportedAttributeType => "NotSupportedAttributeType",
            SetVariableStatusEnum::RebootRequired => "RebootRequired",
        }
    }
}

impl std::fmt::Display for SetVariableStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for SetVariableStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for SetVariableStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Status of the operation
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TariffChangeStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "TooManyElements")]
    TooManyElements,
    #[serde(rename = "ConditionNotSupported")]
    ConditionNotSupported,
    #[serde(rename = "TxNotFound")]
    TxNotFound,
    #[serde(rename = "NoCurrencyChange")]
    NoCurrencyChange,
}

impl TariffChangeStatusEnum {
    pub const ALL: &'static [TariffChangeStatusEnum] = &[
        TariffChangeStatusEnum::Accepted,
        TariffChangeStatusEnum::Rejected,
        TariffChangeStatusEnum::TooManyElements,
        TariffChangeStatusEnum::ConditionNotSupported,
        TariffChangeStatusEnum::TxNotFound,
        TariffChangeStatusEnum::NoCurrencyChange,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TariffChangeStatusEnum::Accepted => "Accepted",
            TariffChangeStatusEnum::Rejected => "Rejected",
            TariffChangeStatusEnum::TooManyElements => "TooManyElements",
            TariffChangeStatusEnum::ConditionNotSupported => "ConditionNotSupported",
            TariffChangeStatusEnum::TxNotFound => "TxNotFound",
            TariffChangeStatusEnum::NoCurrencyChange => "NoCurrencyChange",
        }
    }
}

impl std::fmt::Display for TariffChangeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TariffChangeStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TariffChangeStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TariffClearStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NoTariff")]
    NoTariff,
}

impl TariffClearStatusEnum {
    pub const ALL: &'static [TariffClearStatusEnum] = &[
        TariffClearStatusEnum::Accepted,
        TariffClearStatusEnum::Rejected,
        TariffClearStatusEnum::NoTariff,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TariffClearStatusEnum::Accepted => "Accepted",
            TariffClearStatusEnum::Rejected => "Rejected",
            TariffClearStatusEnum::NoTariff => "NoTariff",
        }
    }
}

impl std::fmt::Display for TariffClearStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TariffClearStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TariffClearStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of cost: normal or the minimum or maximum cost.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TariffCostEnum {
    #[serde(rename = "NormalCost")]
    NormalCost,
    #[serde(rename = "MinCost")]
    MinCost,
    #[serde(rename = "MaxCost")]
    MaxCost,
}

impl TariffCostEnum {
    pub const ALL: &'static [TariffCostEnum] = &[
        TariffCostEnum::NormalCost,
        TariffCostEnum::MinCost,
        TariffCostEnum::MaxCost,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TariffCostEnum::NormalCost => "NormalCost",
            TariffCostEnum::MinCost => "MinCost",
            TariffCostEnum::MaxCost => "MaxCost",
        }
    }
}

impl std::fmt::Display for TariffCostEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TariffCostEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TariffCostEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Status of operation
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TariffGetStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NoTariff")]
    NoTariff,
}

impl TariffGetStatusEnum {
    pub const ALL: &'static [TariffGetStatusEnum] = &[
        TariffGetStatusEnum::Accepted,
        TariffGetStatusEnum::Rejected,
        TariffGetStatusEnum::NoTariff,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TariffGetStatusEnum::Accepted => "Accepted",
            TariffGetStatusEnum::Rejected => "Rejected",
            TariffGetStatusEnum::NoTariff => "NoTariff",
        }
    }
}

impl std::fmt::Display for TariffGetStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TariffGetStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TariffGetStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Kind of tariff (driver/default)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TariffKindEnum {
    #[serde(rename = "DefaultTariff")]
    DefaultTariff,
    #[serde(rename = "DriverTariff")]
    DriverTariff,
}

impl TariffKindEnum {
    pub const ALL: &'static [TariffKindEnum] =
        &[TariffKindEnum::DefaultTariff, TariffKindEnum::DriverTariff];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TariffKindEnum::DefaultTariff => "DefaultTariff",
            TariffKindEnum::DriverTariff => "DriverTariff",
        }
    }
}

impl std::fmt::Display for TariffKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TariffKindEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TariffKindEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TariffSetStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "TooManyElements")]
    TooManyElements,
    #[serde(rename = "ConditionNotSupported")]
    ConditionNotSupported,
    #[serde(rename = "DuplicateTariffId")]
    DuplicateTariffId,
}

impl TariffSetStatusEnum {
    pub const ALL: &'static [TariffSetStatusEnum] = &[
        TariffSetStatusEnum::Accepted,
        TariffSetStatusEnum::Rejected,
        TariffSetStatusEnum::TooManyElements,
        TariffSetStatusEnum::ConditionNotSupported,
        TariffSetStatusEnum::DuplicateTariffId,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TariffSetStatusEnum::Accepted => "Accepted",
            TariffSetStatusEnum::Rejected => "Rejected",
            TariffSetStatusEnum::TooManyElements => "TooManyElements",
            TariffSetStatusEnum::ConditionNotSupported => "ConditionNotSupported",
            TariffSetStatusEnum::DuplicateTariffId => "DuplicateTariffId",
        }
    }
}

impl std::fmt::Display for TariffSetStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TariffSetStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TariffSetStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the type of this event.
/// The first TransactionEvent of a transaction SHALL contain: "Started" The last TransactionEvent of a transaction SHALL contain: "Ended" All others SHALL contain: "Updated"
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TransactionEventEnum {
    #[serde(rename = "Ended")]
    Ended,
    #[serde(rename = "Started")]
    Started,
    #[serde(rename = "Updated")]
    Updated,
}

impl TransactionEventEnum {
    pub const ALL: &'static [TransactionEventEnum] = &[
        TransactionEventEnum::Ended,
        TransactionEventEnum::Started,
        TransactionEventEnum::Updated,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TransactionEventEnum::Ended => "Ended",
            TransactionEventEnum::Started => "Started",
            TransactionEventEnum::Updated => "Updated",
        }
    }
}

impl std::fmt::Display for TransactionEventEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TransactionEventEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TransactionEventEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates whether the Charging Station will send the requested notification or not.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TriggerMessageStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "NotImplemented")]
    NotImplemented,
}

impl TriggerMessageStatusEnum {
    pub const ALL: &'static [TriggerMessageStatusEnum] = &[
        TriggerMessageStatusEnum::Accepted,
        TriggerMessageStatusEnum::Rejected,
        TriggerMessageStatusEnum::NotImplemented,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TriggerMessageStatusEnum::Accepted => "Accepted",
            TriggerMessageStatusEnum::Rejected => "Rejected",
            TriggerMessageStatusEnum::NotImplemented => "NotImplemented",
        }
    }
}

impl std::fmt::Display for TriggerMessageStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TriggerMessageStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TriggerMessageStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Reason the Charging Station sends this message to the CSMS
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TriggerReasonEnum {
    #[serde(rename = "AbnormalCondition")]
    AbnormalCondition,
    #[serde(rename = "Authorized")]
    Authorized,
    #[serde(rename = "CablePluggedIn")]
    CablePluggedIn,
    #[serde(rename = "ChargingRateChanged")]
    ChargingRateChanged,
    #[serde(rename = "ChargingStateChanged")]
    ChargingStateChanged,
    #[serde(rename = "CostLimitReached")]
    CostLimitReached,
    #[serde(rename = "Deauthorized")]
    Deauthorized,
    #[serde(rename = "EnergyLimitReached")]
    EnergyLimitReached,
    #[serde(rename = "EVCommunicationLost")]
    EVCommunicationLost,
    #[serde(rename = "EVConnectTimeout")]
    EVConnectTimeout,
    #[serde(rename = "EVDeparted")]
    EVDeparted,
    #[serde(rename = "EVDetected")]
    EVDetected,
    #[serde(rename = "LimitSet")]
    LimitSet,
    #[serde(rename = "MeterValueClock")]
    MeterValueClock,
    #[serde(rename = "MeterValuePeriodic")]
    MeterValuePeriodic,
    #[serde(rename = "OperationModeChanged")]
    OperationModeChanged,
    #[serde(rename = "RemoteStart")]
    RemoteStart,
    #[serde(rename = "RemoteStop")]
    RemoteStop,
    #[serde(rename = "ResetCommand")]
    ResetCommand,
    #[serde(rename = "RunningCost")]
    RunningCost,
    #[serde(rename = "SignedDataReceived")]
    SignedDataReceived,
    #[serde(rename = "SoCLimitReached")]
    SoCLimitReached,
    #[serde(rename = "StopAuthorized")]
    StopAuthorized,
    #[serde(rename = "TariffChanged")]
    TariffChanged,
    #[serde(rename = "TariffNotAccepted")]
    TariffNotAccepted,
    #[serde(rename = "TimeLimitReached")]
    TimeLimitReached,
    #[serde(rename = "Trigger")]
    Trigger,
    #[serde(rename = "TxResumed")]
    TxResumed,
    #[serde(rename = "UnlockCommand")]
    UnlockCommand,
}

impl TriggerReasonEnum {
    pub const ALL: &'static [TriggerReasonEnum] = &[
        TriggerReasonEnum::AbnormalCondition,
        TriggerReasonEnum::Authorized,
        TriggerReasonEnum::CablePluggedIn,
        TriggerReasonEnum::ChargingRateChanged,
        TriggerReasonEnum::ChargingStateChanged,
        TriggerReasonEnum::CostLimitReached,
        TriggerReasonEnum::Deauthorized,
        TriggerReasonEnum::EnergyLimitReached,
        TriggerReasonEnum::EVCommunicationLost,
        TriggerReasonEnum::EVConnectTimeout,
        TriggerReasonEnum::EVDeparted,
        TriggerReasonEnum::EVDetected,
        TriggerReasonEnum::LimitSet,
        TriggerReasonEnum::MeterValueClock,
        TriggerReasonEnum::MeterValuePeriodic,
        TriggerReasonEnum::OperationModeChanged,
        TriggerReasonEnum::RemoteStart,
        TriggerReasonEnum::RemoteStop,
        TriggerReasonEnum::ResetCommand,
        TriggerReasonEnum::RunningCost,
        TriggerReasonEnum::SignedDataReceived,
        TriggerReasonEnum::SoCLimitReached,
        TriggerReasonEnum::StopAuthorized,
        TriggerReasonEnum::TariffChanged,
        TriggerReasonEnum::TariffNotAccepted,
        TriggerReasonEnum::TimeLimitReached,
        TriggerReasonEnum::Trigger,
        TriggerReasonEnum::TxResumed,
        TriggerReasonEnum::UnlockCommand,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            TriggerReasonEnum::AbnormalCondition => "AbnormalCondition",
            TriggerReasonEnum::Authorized => "Authorized",
            TriggerReasonEnum::CablePluggedIn => "CablePluggedIn",
            TriggerReasonEnum::ChargingRateChanged => "ChargingRateChanged",
            TriggerReasonEnum::ChargingStateChanged => "ChargingStateChanged",
            TriggerReasonEnum::CostLimitReached => "CostLimitReached",
            TriggerReasonEnum::Deauthorized => "Deauthorized",
            TriggerReasonEnum::EnergyLimitReached => "EnergyLimitReached",
            TriggerReasonEnum::EVCommunicationLost => "EVCommunicationLost",
            TriggerReasonEnum::EVConnectTimeout => "EVConnectTimeout",
            TriggerReasonEnum::EVDeparted => "EVDeparted",
            TriggerReasonEnum::EVDetected => "EVDetected",
            TriggerReasonEnum::LimitSet => "LimitSet",
            TriggerReasonEnum::MeterValueClock => "MeterValueClock",
            TriggerReasonEnum::MeterValuePeriodic => "MeterValuePeriodic",
            TriggerReasonEnum::OperationModeChanged => "OperationModeChanged",
            TriggerReasonEnum::RemoteStart => "RemoteStart",
            TriggerReasonEnum::RemoteStop => "RemoteStop",
            TriggerReasonEnum::ResetCommand => "ResetCommand",
            TriggerReasonEnum::RunningCost => "RunningCost",
            TriggerReasonEnum::SignedDataReceived => "SignedDataReceived",
            TriggerReasonEnum::SoCLimitReached => "SoCLimitReached",
            TriggerReasonEnum::StopAuthorized => "StopAuthorized",
            TriggerReasonEnum::TariffChanged => "TariffChanged",
            TriggerReasonEnum::TariffNotAccepted => "TariffNotAccepted",
            TriggerReasonEnum::TimeLimitReached => "TimeLimitReached",
            TriggerReasonEnum::Trigger => "Trigger",
            TriggerReasonEnum::TxResumed => "TxResumed",
            TriggerReasonEnum::UnlockCommand => "UnlockCommand",
        }
    }
}

impl std::fmt::Display for TriggerReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for TriggerReasonEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for TriggerReasonEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This indicates whether the Charging Station has unlocked the connector.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UnlockStatusEnum {
    #[serde(rename = "Unlocked")]
    Unlocked,
    #[serde(rename = "UnlockFailed")]
    UnlockFailed,
    #[serde(rename = "OngoingAuthorizedTransaction")]
    OngoingAuthorizedTransaction,
    #[serde(rename = "UnknownConnector")]
    UnknownConnector,
}

impl UnlockStatusEnum {
    pub const ALL: &'static [UnlockStatusEnum] = &[
        UnlockStatusEnum::Unlocked,
        UnlockStatusEnum::UnlockFailed,
        UnlockStatusEnum::OngoingAuthorizedTransaction,
        UnlockStatusEnum::UnknownConnector,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            UnlockStatusEnum::Unlocked => "Unlocked",
            UnlockStatusEnum::UnlockFailed => "UnlockFailed",
            UnlockStatusEnum::OngoingAuthorizedTransaction => "OngoingAuthorizedTransaction",
            UnlockStatusEnum::UnknownConnector => "UnknownConnector",
        }
    }
}

impl std::fmt::Display for UnlockStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for UnlockStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for UnlockStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Indicates whether the Local Controller succeeded in unpublishing the firmware.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UnpublishFirmwareStatusEnum {
    #[serde(rename = "DownloadOngoing")]
    DownloadOngoing,
    #[serde(rename = "NoFirmware")]
    NoFirmware,
    #[serde(rename = "Unpublished")]
    Unpublished,
}

impl UnpublishFirmwareStatusEnum {
    pub const ALL: &'static [UnpublishFirmwareStatusEnum] = &[
        UnpublishFirmwareStatusEnum::DownloadOngoing,
        UnpublishFirmwareStatusEnum::NoFirmware,
        UnpublishFirmwareStatusEnum::Unpublished,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            UnpublishFirmwareStatusEnum::DownloadOngoing => "DownloadOngoing",
            UnpublishFirmwareStatusEnum::NoFirmware => "NoFirmware",
            UnpublishFirmwareStatusEnum::Unpublished => "Unpublished",
        }
    }
}

impl std::fmt::Display for UnpublishFirmwareStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for UnpublishFirmwareStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for UnpublishFirmwareStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the type of update (full or differential) of this request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UpdateEnum {
    #[serde(rename = "Differential")]
    Differential,
    #[serde(rename = "Full")]
    Full,
}

impl UpdateEnum {
    pub const ALL: &'static [UpdateEnum] = &[UpdateEnum::Differential, UpdateEnum::Full];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            UpdateEnum::Differential => "Differential",
            UpdateEnum::Full => "Full",
        }
    }
}

impl std::fmt::Display for UpdateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for UpdateEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for UpdateEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This field indicates whether the Charging Station was able to accept the request.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UpdateFirmwareStatusEnum {
    #[serde(rename = "Accepted")]
    Accepted,
    #[serde(rename = "Rejected")]
    Rejected,
    #[serde(rename = "AcceptedCanceled")]
    AcceptedCanceled,
    #[serde(rename = "InvalidCertificate")]
    InvalidCertificate,
    #[serde(rename = "RevokedCertificate")]
    RevokedCertificate,
}

impl UpdateFirmwareStatusEnum {
    pub const ALL: &'static [UpdateFirmwareStatusEnum] = &[
        UpdateFirmwareStatusEnum::Accepted,
        UpdateFirmwareStatusEnum::Rejected,
        UpdateFirmwareStatusEnum::AcceptedCanceled,
        UpdateFirmwareStatusEnum::InvalidCertificate,
        UpdateFirmwareStatusEnum::RevokedCertificate,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            UpdateFirmwareStatusEnum::Accepted => "Accepted",
            UpdateFirmwareStatusEnum::Rejected => "Rejected",
            UpdateFirmwareStatusEnum::AcceptedCanceled => "AcceptedCanceled",
            UpdateFirmwareStatusEnum::InvalidCertificate => "InvalidCertificate",
            UpdateFirmwareStatusEnum::RevokedCertificate => "RevokedCertificate",
        }
    }
}

impl std::fmt::Display for UpdateFirmwareStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for UpdateFirmwareStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for UpdateFirmwareStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// This contains the status of the log upload.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum UploadLogStatusEnum {
    #[serde(rename = "BadMessage")]
    BadMessage,
    #[serde(rename = "Idle")]
    Idle,
    #[serde(rename = "NotSupportedOperation")]
    NotSupportedOperation,
    #[serde(rename = "PermissionDenied")]
    PermissionDenied,
    #[serde(rename = "Uploaded")]
    Uploaded,
    #[serde(rename = "UploadFailure")]
    UploadFailure,
    #[serde(rename = "Uploading")]
    Uploading,
    #[serde(rename = "AcceptedCanceled")]
    AcceptedCanceled,
}

impl UploadLogStatusEnum {
    pub const ALL: &'static [UploadLogStatusEnum] = &[
        UploadLogStatusEnum::BadMessage,
        UploadLogStatusEnum::Idle,
        UploadLogStatusEnum::NotSupportedOperation,
        UploadLogStatusEnum::PermissionDenied,
        UploadLogStatusEnum::Uploaded,
        UploadLogStatusEnum::UploadFailure,
        UploadLogStatusEnum::Uploading,
        UploadLogStatusEnum::AcceptedCanceled,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            UploadLogStatusEnum::BadMessage => "BadMessage",
            UploadLogStatusEnum::Idle => "Idle",
            UploadLogStatusEnum::NotSupportedOperation => "NotSupportedOperation",
            UploadLogStatusEnum::PermissionDenied => "PermissionDenied",
            UploadLogStatusEnum::Uploaded => "Uploaded",
            UploadLogStatusEnum::UploadFailure => "UploadFailure",
            UploadLogStatusEnum::Uploading => "Uploading",
            UploadLogStatusEnum::AcceptedCanceled => "AcceptedCanceled",
        }
    }
}

impl std::fmt::Display for UploadLogStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for UploadLogStatusEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for UploadLogStatusEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

/// Type of VPN
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum VPNEnum {
    #[serde(rename = "IKEv2")]
    IKEv2,
    #[serde(rename = "IPSec")]
    IPSec,
    #[serde(rename = "L2TP")]
    L2TP,
    #[serde(rename = "PPTP")]
    PPTP,
}

impl VPNEnum {
    pub const ALL: &'static [VPNEnum] =
        &[VPNEnum::IKEv2, VPNEnum::IPSec, VPNEnum::L2TP, VPNEnum::PPTP];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            VPNEnum::IKEv2 => "IKEv2",
            VPNEnum::IPSec => "IPSec",
            VPNEnum::L2TP => "L2TP",
            VPNEnum::PPTP => "PPTP",
        }
    }
}

impl std::fmt::Display for VPNEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for VPNEnum {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Self::ALL
            .iter()
            .copied()
            .find(|v| v.as_str() == s)
            .ok_or(())
    }
}

impl Validate for VPNEnum {
    #[inline]
    fn validate(&self, _: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}