codetics-ocpp201 0.1.0

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

//! OCPP 2.0.1 enumerations.

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

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

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

/// ID_ Token. Status. Authorization_ Status
/// 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(())
    }
}

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

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

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

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

/// Source of the charging limit.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingLimitSourceEnum {
    #[serde(rename = "EMS")]
    EMS,
    #[serde(rename = "Other")]
    Other,
    #[serde(rename = "SO")]
    SO,
    #[serde(rename = "CSO")]
    CSO,
}

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

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

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

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

/// Charging_ Profile. Charging_ Profile_ Kind. Charging_ Profile_ Kind_ Code
/// 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,
}

impl ChargingProfileKindEnum {
    pub const ALL: &'static [ChargingProfileKindEnum] = &[
        ChargingProfileKindEnum::Absolute,
        ChargingProfileKindEnum::Recurring,
        ChargingProfileKindEnum::Relative,
    ];
    /// 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",
        }
    }
}

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

/// Charging_ Profile. Charging_ Profile_ Purpose. Charging_ Profile_ Purpose_ Code
/// 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,
}

impl ChargingProfilePurposeEnum {
    pub const ALL: &'static [ChargingProfilePurposeEnum] = &[
        ChargingProfilePurposeEnum::ChargingStationExternalConstraints,
        ChargingProfilePurposeEnum::ChargingStationMaxProfile,
        ChargingProfilePurposeEnum::TxDefaultProfile,
        ChargingProfilePurposeEnum::TxProfile,
    ];
    /// 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",
        }
    }
}

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

/// Returns whether the Charging Station has been able to process the message successfully. This does not guarantee the schedule will be followed to the letter. There might be other constraints the Charging Station may need to take into account.
#[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(())
    }
}

/// Transaction. State. Transaction_ State_ Code
/// Current charging state, is required when state
/// has changed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ChargingStateEnum {
    #[serde(rename = "Charging")]
    Charging,
    #[serde(rename = "EVConnected")]
    EVConnected,
    #[serde(rename = "SuspendedEV")]
    SuspendedEV,
    #[serde(rename = "SuspendedEVSE")]
    SuspendedEVSE,
    #[serde(rename = "Idle")]
    Idle,
}

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

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

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 field specifies the connector type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ConnectorEnum {
    #[serde(rename = "cCCS1")]
    CCCS1,
    #[serde(rename = "cCCS2")]
    CCCS2,
    #[serde(rename = "cG105")]
    CG105,
    #[serde(rename = "cTesla")]
    CTesla,
    #[serde(rename = "cType1")]
    CType1,
    #[serde(rename = "cType2")]
    CType2,
    #[serde(rename = "s309-1P-16A")]
    S3091P16A,
    #[serde(rename = "s309-1P-32A")]
    S3091P32A,
    #[serde(rename = "s309-3P-16A")]
    S3093P16A,
    #[serde(rename = "s309-3P-32A")]
    S3093P32A,
    #[serde(rename = "sBS1361")]
    SBS1361,
    #[serde(rename = "sCEE-7-7")]
    SCEE77,
    #[serde(rename = "sType2")]
    SType2,
    #[serde(rename = "sType3")]
    SType3,
    #[serde(rename = "Other1PhMax16A")]
    Other1PhMax16A,
    #[serde(rename = "Other1PhOver16A")]
    Other1PhOver16A,
    #[serde(rename = "Other3Ph")]
    Other3Ph,
    #[serde(rename = "Pan")]
    Pan,
    #[serde(rename = "wInductive")]
    WInductive,
    #[serde(rename = "wResonant")]
    WResonant,
    #[serde(rename = "Undetermined")]
    Undetermined,
    #[serde(rename = "Unknown")]
    Unknown,
}

impl ConnectorEnum {
    pub const ALL: &'static [ConnectorEnum] = &[
        ConnectorEnum::CCCS1,
        ConnectorEnum::CCCS2,
        ConnectorEnum::CG105,
        ConnectorEnum::CTesla,
        ConnectorEnum::CType1,
        ConnectorEnum::CType2,
        ConnectorEnum::S3091P16A,
        ConnectorEnum::S3091P32A,
        ConnectorEnum::S3093P16A,
        ConnectorEnum::S3093P32A,
        ConnectorEnum::SBS1361,
        ConnectorEnum::SCEE77,
        ConnectorEnum::SType2,
        ConnectorEnum::SType3,
        ConnectorEnum::Other1PhMax16A,
        ConnectorEnum::Other1PhOver16A,
        ConnectorEnum::Other3Ph,
        ConnectorEnum::Pan,
        ConnectorEnum::WInductive,
        ConnectorEnum::WResonant,
        ConnectorEnum::Undetermined,
        ConnectorEnum::Unknown,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            ConnectorEnum::CCCS1 => "cCCS1",
            ConnectorEnum::CCCS2 => "cCCS2",
            ConnectorEnum::CG105 => "cG105",
            ConnectorEnum::CTesla => "cTesla",
            ConnectorEnum::CType1 => "cType1",
            ConnectorEnum::CType2 => "cType2",
            ConnectorEnum::S3091P16A => "s309-1P-16A",
            ConnectorEnum::S3091P32A => "s309-1P-32A",
            ConnectorEnum::S3093P16A => "s309-3P-16A",
            ConnectorEnum::S3093P32A => "s309-3P-32A",
            ConnectorEnum::SBS1361 => "sBS1361",
            ConnectorEnum::SCEE77 => "sCEE-7-7",
            ConnectorEnum::SType2 => "sType2",
            ConnectorEnum::SType3 => "sType3",
            ConnectorEnum::Other1PhMax16A => "Other1PhMax16A",
            ConnectorEnum::Other1PhOver16A => "Other1PhOver16A",
            ConnectorEnum::Other3Ph => "Other3Ph",
            ConnectorEnum::Pan => "Pan",
            ConnectorEnum::WInductive => "wInductive",
            ConnectorEnum::WResonant => "wResonant",
            ConnectorEnum::Undetermined => "Undetermined",
            ConnectorEnum::Unknown => "Unknown",
        }
    }
}

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

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

impl Validate for ConnectorEnum {
    #[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(())
    }
}

/// Cost. Cost_ Kind. Cost_ Kind_ Code
/// 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(())
    }
}

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

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

impl DisplayMessageStatusEnum {
    pub const ALL: &'static [DisplayMessageStatusEnum] = &[
        DisplayMessageStatusEnum::Accepted,
        DisplayMessageStatusEnum::NotSupportedMessageFormat,
        DisplayMessageStatusEnum::Rejected,
        DisplayMessageStatusEnum::NotSupportedPriority,
        DisplayMessageStatusEnum::NotSupportedState,
        DisplayMessageStatusEnum::UnknownTransaction,
    ];
    /// 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",
        }
    }
}

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

/// Charging_ Needs. Requested. Energy_ Transfer_ Mode_ Code
/// Mode of energy transfer requested by the EV.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum EnergyTransferModeEnum {
    #[serde(rename = "DC")]
    DC,
    #[serde(rename = "AC_single_phase")]
    ACSinglePhase,
    #[serde(rename = "AC_two_phase")]
    ACTwoPhase,
    #[serde(rename = "AC_three_phase")]
    ACThreePhase,
}

impl EnergyTransferModeEnum {
    pub const ALL: &'static [EnergyTransferModeEnum] = &[
        EnergyTransferModeEnum::DC,
        EnergyTransferModeEnum::ACSinglePhase,
        EnergyTransferModeEnum::ACTwoPhase,
        EnergyTransferModeEnum::ACThreePhase,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            EnergyTransferModeEnum::DC => "DC",
            EnergyTransferModeEnum::ACSinglePhase => "AC_single_phase",
            EnergyTransferModeEnum::ACTwoPhase => "AC_two_phase",
            EnergyTransferModeEnum::ACThreePhase => "AC_three_phase",
        }
    }
}

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 monitor that triggered 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(())
    }
}

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

/// The Charging Station will indicate if it was
/// able to process the request
#[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,
}

impl GetCertificateIdUseEnum {
    pub const ALL: &'static [GetCertificateIdUseEnum] = &[
        GetCertificateIdUseEnum::V2GRootCertificate,
        GetCertificateIdUseEnum::MORootCertificate,
        GetCertificateIdUseEnum::CSMSRootCertificate,
        GetCertificateIdUseEnum::V2GCertificateChain,
        GetCertificateIdUseEnum::ManufacturerRootCertificate,
    ];
    /// 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",
        }
    }
}

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

/// Result status of getting the variable.
#[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(())
    }
}

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

/// Enumeration of possible idToken types.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum IdTokenEnum {
    #[serde(rename = "Central")]
    Central,
    #[serde(rename = "eMAID")]
    EMAID,
    #[serde(rename = "ISO14443")]
    ISO14443,
    #[serde(rename = "ISO15693")]
    ISO15693,
    #[serde(rename = "KeyCode")]
    KeyCode,
    #[serde(rename = "Local")]
    Local,
    #[serde(rename = "MacAddress")]
    MacAddress,
    #[serde(rename = "NoAuthorization")]
    NoAuthorization,
}

impl IdTokenEnum {
    pub const ALL: &'static [IdTokenEnum] = &[
        IdTokenEnum::Central,
        IdTokenEnum::EMAID,
        IdTokenEnum::ISO14443,
        IdTokenEnum::ISO15693,
        IdTokenEnum::KeyCode,
        IdTokenEnum::Local,
        IdTokenEnum::MacAddress,
        IdTokenEnum::NoAuthorization,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            IdTokenEnum::Central => "Central",
            IdTokenEnum::EMAID => "eMAID",
            IdTokenEnum::ISO14443 => "ISO14443",
            IdTokenEnum::ISO15693 => "ISO15693",
            IdTokenEnum::KeyCode => "KeyCode",
            IdTokenEnum::Local => "Local",
            IdTokenEnum::MacAddress => "MacAddress",
            IdTokenEnum::NoAuthorization => "NoAuthorization",
        }
    }
}

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

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

impl Validate for IdTokenEnum {
    #[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 = "CSMSRootCertificate")]
    CSMSRootCertificate,
    #[serde(rename = "ManufacturerRootCertificate")]
    ManufacturerRootCertificate,
}

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

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

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

/// Sampled_ Value. Location. Location_ Code
/// 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,
}

impl LocationEnum {
    pub const ALL: &'static [LocationEnum] = &[
        LocationEnum::Body,
        LocationEnum::Cable,
        LocationEnum::EV,
        LocationEnum::Inlet,
        LocationEnum::Outlet,
    ];
    /// 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",
        }
    }
}

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

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

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

/// Sampled_ Value. Measurand. Measurand_ Code
/// 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.Import")]
    CurrentImport,
    #[serde(rename = "Current.Offered")]
    CurrentOffered,
    #[serde(rename = "Energy.Active.Export.Register")]
    EnergyActiveExportRegister,
    #[serde(rename = "Energy.Active.Import.Register")]
    EnergyActiveImportRegister,
    #[serde(rename = "Energy.Reactive.Export.Register")]
    EnergyReactiveExportRegister,
    #[serde(rename = "Energy.Reactive.Import.Register")]
    EnergyReactiveImportRegister,
    #[serde(rename = "Energy.Active.Export.Interval")]
    EnergyActiveExportInterval,
    #[serde(rename = "Energy.Active.Import.Interval")]
    EnergyActiveImportInterval,
    #[serde(rename = "Energy.Active.Net")]
    EnergyActiveNet,
    #[serde(rename = "Energy.Reactive.Export.Interval")]
    EnergyReactiveExportInterval,
    #[serde(rename = "Energy.Reactive.Import.Interval")]
    EnergyReactiveImportInterval,
    #[serde(rename = "Energy.Reactive.Net")]
    EnergyReactiveNet,
    #[serde(rename = "Energy.Apparent.Net")]
    EnergyApparentNet,
    #[serde(rename = "Energy.Apparent.Import")]
    EnergyApparentImport,
    #[serde(rename = "Energy.Apparent.Export")]
    EnergyApparentExport,
    #[serde(rename = "Frequency")]
    Frequency,
    #[serde(rename = "Power.Active.Export")]
    PowerActiveExport,
    #[serde(rename = "Power.Active.Import")]
    PowerActiveImport,
    #[serde(rename = "Power.Factor")]
    PowerFactor,
    #[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,
}

impl MeasurandEnum {
    pub const ALL: &'static [MeasurandEnum] = &[
        MeasurandEnum::CurrentExport,
        MeasurandEnum::CurrentImport,
        MeasurandEnum::CurrentOffered,
        MeasurandEnum::EnergyActiveExportRegister,
        MeasurandEnum::EnergyActiveImportRegister,
        MeasurandEnum::EnergyReactiveExportRegister,
        MeasurandEnum::EnergyReactiveImportRegister,
        MeasurandEnum::EnergyActiveExportInterval,
        MeasurandEnum::EnergyActiveImportInterval,
        MeasurandEnum::EnergyActiveNet,
        MeasurandEnum::EnergyReactiveExportInterval,
        MeasurandEnum::EnergyReactiveImportInterval,
        MeasurandEnum::EnergyReactiveNet,
        MeasurandEnum::EnergyApparentNet,
        MeasurandEnum::EnergyApparentImport,
        MeasurandEnum::EnergyApparentExport,
        MeasurandEnum::Frequency,
        MeasurandEnum::PowerActiveExport,
        MeasurandEnum::PowerActiveImport,
        MeasurandEnum::PowerFactor,
        MeasurandEnum::PowerOffered,
        MeasurandEnum::PowerReactiveExport,
        MeasurandEnum::PowerReactiveImport,
        MeasurandEnum::SoC,
        MeasurandEnum::Voltage,
    ];
    /// Value as it appears on the wire.
    pub const fn as_str(&self) -> &'static str {
        match self {
            MeasurandEnum::CurrentExport => "Current.Export",
            MeasurandEnum::CurrentImport => "Current.Import",
            MeasurandEnum::CurrentOffered => "Current.Offered",
            MeasurandEnum::EnergyActiveExportRegister => "Energy.Active.Export.Register",
            MeasurandEnum::EnergyActiveImportRegister => "Energy.Active.Import.Register",
            MeasurandEnum::EnergyReactiveExportRegister => "Energy.Reactive.Export.Register",
            MeasurandEnum::EnergyReactiveImportRegister => "Energy.Reactive.Import.Register",
            MeasurandEnum::EnergyActiveExportInterval => "Energy.Active.Export.Interval",
            MeasurandEnum::EnergyActiveImportInterval => "Energy.Active.Import.Interval",
            MeasurandEnum::EnergyActiveNet => "Energy.Active.Net",
            MeasurandEnum::EnergyReactiveExportInterval => "Energy.Reactive.Export.Interval",
            MeasurandEnum::EnergyReactiveImportInterval => "Energy.Reactive.Import.Interval",
            MeasurandEnum::EnergyReactiveNet => "Energy.Reactive.Net",
            MeasurandEnum::EnergyApparentNet => "Energy.Apparent.Net",
            MeasurandEnum::EnergyApparentImport => "Energy.Apparent.Import",
            MeasurandEnum::EnergyApparentExport => "Energy.Apparent.Export",
            MeasurandEnum::Frequency => "Frequency",
            MeasurandEnum::PowerActiveExport => "Power.Active.Export",
            MeasurandEnum::PowerActiveImport => "Power.Active.Import",
            MeasurandEnum::PowerFactor => "Power.Factor",
            MeasurandEnum::PowerOffered => "Power.Offered",
            MeasurandEnum::PowerReactiveExport => "Power.Reactive.Export",
            MeasurandEnum::PowerReactiveImport => "Power.Reactive.Import",
            MeasurandEnum::SoC => "SoC",
            MeasurandEnum::Voltage => "Voltage",
        }
    }
}

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

/// Message_ Content. Format. Message_ Format_ Code
/// 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,
}

impl MessageFormatEnum {
    pub const ALL: &'static [MessageFormatEnum] = &[
        MessageFormatEnum::ASCII,
        MessageFormatEnum::HTML,
        MessageFormatEnum::URI,
        MessageFormatEnum::UTF8,
    ];
    /// 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",
        }
    }
}

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

impl MessageStateEnum {
    pub const ALL: &'static [MessageStateEnum] = &[
        MessageStateEnum::Charging,
        MessageStateEnum::Faulted,
        MessageStateEnum::Idle,
        MessageStateEnum::Unavailable,
    ];
    /// 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",
        }
    }
}

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 = "StatusNotification")]
    StatusNotification,
    #[serde(rename = "TransactionEvent")]
    TransactionEvent,
    #[serde(rename = "SignCombinedCertificate")]
    SignCombinedCertificate,
    #[serde(rename = "PublishFirmwareStatusNotification")]
    PublishFirmwareStatusNotification,
}

impl MessageTriggerEnum {
    pub const ALL: &'static [MessageTriggerEnum] = &[
        MessageTriggerEnum::BootNotification,
        MessageTriggerEnum::LogStatusNotification,
        MessageTriggerEnum::FirmwareStatusNotification,
        MessageTriggerEnum::Heartbeat,
        MessageTriggerEnum::MeterValues,
        MessageTriggerEnum::SignChargingStationCertificate,
        MessageTriggerEnum::SignV2GCertificate,
        MessageTriggerEnum::StatusNotification,
        MessageTriggerEnum::TransactionEvent,
        MessageTriggerEnum::SignCombinedCertificate,
        MessageTriggerEnum::PublishFirmwareStatusNotification,
    ];
    /// 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::StatusNotification => "StatusNotification",
            MessageTriggerEnum::TransactionEvent => "TransactionEvent",
            MessageTriggerEnum::SignCombinedCertificate => "SignCombinedCertificate",
            MessageTriggerEnum::PublishFirmwareStatusNotification => {
                "PublishFirmwareStatusNotification"
            }
        }
    }
}

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

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

impl MonitorEnum {
    pub const ALL: &'static [MonitorEnum] = &[
        MonitorEnum::UpperThreshold,
        MonitorEnum::LowerThreshold,
        MonitorEnum::Delta,
        MonitorEnum::Periodic,
        MonitorEnum::PeriodicClockAligned,
    ];
    /// 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",
        }
    }
}

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

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

impl NotifyEVChargingNeedsStatusEnum {
    pub const ALL: &'static [NotifyEVChargingNeedsStatusEnum] = &[
        NotifyEVChargingNeedsStatusEnum::Accepted,
        NotifyEVChargingNeedsStatusEnum::Rejected,
        NotifyEVChargingNeedsStatusEnum::Processing,
    ];
    /// 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",
        }
    }
}

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.
#[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,
}

impl OCPPInterfaceEnum {
    pub const ALL: &'static [OCPPInterfaceEnum] = &[
        OCPPInterfaceEnum::Wired0,
        OCPPInterfaceEnum::Wired1,
        OCPPInterfaceEnum::Wired2,
        OCPPInterfaceEnum::Wired3,
        OCPPInterfaceEnum::Wireless0,
        OCPPInterfaceEnum::Wireless1,
        OCPPInterfaceEnum::Wireless2,
        OCPPInterfaceEnum::Wireless3,
    ];
    /// 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",
        }
    }
}

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

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

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

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

/// Communication_ Function. OCPP_ Version. OCPP_ Version_ Code
/// Defines the OCPP version used for this communication function.
#[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,
}

impl OCPPVersionEnum {
    pub const ALL: &'static [OCPPVersionEnum] = &[
        OCPPVersionEnum::OCPP12,
        OCPPVersionEnum::OCPP15,
        OCPPVersionEnum::OCPP16,
        OCPPVersionEnum::OCPP20,
    ];
    /// 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",
        }
    }
}

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

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

/// Sampled_ Value. Phase. Phase_ Code
/// 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(())
    }
}

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

/// Sampled_ Value. Context. Reading_ Context_ Code
/// 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(())
    }
}

/// Transaction. Stopped_ Reason. EOT_ Reason_ Code
/// This contains the reason why the transaction was stopped. MAY only be omitted when Reason 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 = "Local")]
    Local,
    #[serde(rename = "LocalOutOfCredit")]
    LocalOutOfCredit,
    #[serde(rename = "MasterPass")]
    MasterPass,
    #[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,
}

impl ReasonEnum {
    pub const ALL: &'static [ReasonEnum] = &[
        ReasonEnum::DeAuthorized,
        ReasonEnum::EmergencyStop,
        ReasonEnum::EnergyLimitReached,
        ReasonEnum::EVDisconnected,
        ReasonEnum::GroundFault,
        ReasonEnum::ImmediateReset,
        ReasonEnum::Local,
        ReasonEnum::LocalOutOfCredit,
        ReasonEnum::MasterPass,
        ReasonEnum::Other,
        ReasonEnum::OvercurrentFault,
        ReasonEnum::PowerLoss,
        ReasonEnum::PowerQuality,
        ReasonEnum::Reboot,
        ReasonEnum::Remote,
        ReasonEnum::SOCLimitReached,
        ReasonEnum::StoppedByEV,
        ReasonEnum::TimeLimitReached,
        ReasonEnum::Timeout,
    ];
    /// 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::Local => "Local",
            ReasonEnum::LocalOutOfCredit => "LocalOutOfCredit",
            ReasonEnum::MasterPass => "MasterPass",
            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",
        }
    }
}

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

/// Charging_ Profile. Recurrency_ Kind. Recurrency_ Kind_ Code
/// 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,
}

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

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

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

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

/// 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 = "Authorized")]
    Authorized,
    #[serde(rename = "CablePluggedIn")]
    CablePluggedIn,
    #[serde(rename = "ChargingRateChanged")]
    ChargingRateChanged,
    #[serde(rename = "ChargingStateChanged")]
    ChargingStateChanged,
    #[serde(rename = "Deauthorized")]
    Deauthorized,
    #[serde(rename = "EnergyLimitReached")]
    EnergyLimitReached,
    #[serde(rename = "EVCommunicationLost")]
    EVCommunicationLost,
    #[serde(rename = "EVConnectTimeout")]
    EVConnectTimeout,
    #[serde(rename = "MeterValueClock")]
    MeterValueClock,
    #[serde(rename = "MeterValuePeriodic")]
    MeterValuePeriodic,
    #[serde(rename = "TimeLimitReached")]
    TimeLimitReached,
    #[serde(rename = "Trigger")]
    Trigger,
    #[serde(rename = "UnlockCommand")]
    UnlockCommand,
    #[serde(rename = "StopAuthorized")]
    StopAuthorized,
    #[serde(rename = "EVDeparted")]
    EVDeparted,
    #[serde(rename = "EVDetected")]
    EVDetected,
    #[serde(rename = "RemoteStop")]
    RemoteStop,
    #[serde(rename = "RemoteStart")]
    RemoteStart,
    #[serde(rename = "AbnormalCondition")]
    AbnormalCondition,
    #[serde(rename = "SignedDataReceived")]
    SignedDataReceived,
    #[serde(rename = "ResetCommand")]
    ResetCommand,
}

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

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

/// VPN. Type. VPN_ Code
/// 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(())
    }
}