codetics-ocpp201 0.1.0

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

//! OCPP 2.0.1 request / response payloads.

use ocpp_core::DateTime;
use ocpp_core::validate::{self as v, Path, Validate, Violation};
use serde::{Deserialize, Serialize};

use crate::datatypes::*;
use crate::enums::*;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AuthorizeRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "idToken")]
    pub id_token: IdToken,
    /// The X.509 certificated presented by EV and encoded in PEM format.
    #[serde(
        rename = "certificate",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate: Option<String>,
    #[serde(
        rename = "iso15118CertificateHashData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub iso15118_certificate_hash_data: Option<Vec<OCSPRequestData>>,
}

impl Validate for AuthorizeRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.id_token;
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        if let Some(x) = &self.certificate {
            let p = path.field("certificate");
            v::max_length(x, 5500, &p)?;
        }
        if let Some(x) = &self.iso15118_certificate_hash_data {
            let p = path.field("iso15118CertificateHashData");
            v::items(x, Some(1), Some(4), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AuthorizeResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "idTokenInfo")]
    pub id_token_info: IdTokenInfo,
    #[serde(
        rename = "certificateStatus",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate_status: Option<AuthorizeCertificateStatusEnum>,
}

impl Validate for AuthorizeResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.id_token_info;
            let p = path.field("idTokenInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BootNotificationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "chargingStation")]
    pub charging_station: ChargingStation,
    #[serde(rename = "reason")]
    pub reason: BootReasonEnum,
}

impl Validate for BootNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.charging_station;
            let p = path.field("chargingStation");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BootNotificationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// This contains the CSMS’s current time.
    #[serde(rename = "currentTime")]
    pub current_time: DateTime,
    /// When &lt;&lt;cmn_registrationstatusenumtype,Status&gt;&gt; is Accepted, this contains the heartbeat interval in seconds. If the CSMS returns something other than Accepted, the value of the interval field indicates the minimum wait time before sending a next BootNotification request.
    #[serde(rename = "interval")]
    pub interval: i64,
    #[serde(rename = "status")]
    pub status: RegistrationStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for BootNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CancelReservationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Id of the reservation to cancel.
    #[serde(rename = "reservationId")]
    pub reservation_id: i64,
}

impl Validate for CancelReservationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CancelReservationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: CancelReservationStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for CancelReservationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CertificateSignedRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The signed PEM encoded X.509 certificate. This can also contain the necessary sub CA certificates. In that case, the order of the bundle should follow the certificate chain, starting from the leaf certificate.
    /// The Configuration Variable &lt;&lt;configkey-max-certificate-chain-size,MaxCertificateChainSize&gt;&gt; can be used to limit the maximum size of this field.
    #[serde(rename = "certificateChain")]
    pub certificate_chain: String,
    #[serde(
        rename = "certificateType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate_type: Option<CertificateSigningUseEnum>,
}

impl Validate for CertificateSignedRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.certificate_chain;
            let p = path.field("certificateChain");
            v::max_length(x, 10000, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CertificateSignedResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: CertificateSignedStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for CertificateSignedResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChangeAvailabilityRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "evse", default, skip_serializing_if = "Option::is_none")]
    pub evse: Option<EVSE>,
    #[serde(rename = "operationalStatus")]
    pub operational_status: OperationalStatusEnum,
}

impl Validate for ChangeAvailabilityRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.evse {
            let p = path.field("evse");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChangeAvailabilityResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ChangeAvailabilityStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for ChangeAvailabilityResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearCacheRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearCacheRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearCacheResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ClearCacheStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for ClearCacheResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearChargingProfileRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The Id of the charging profile to clear.
    #[serde(
        rename = "chargingProfileId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_profile_id: Option<i64>,
    #[serde(
        rename = "chargingProfileCriteria",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_profile_criteria: Option<ClearChargingProfile>,
}

impl Validate for ClearChargingProfileRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.charging_profile_criteria {
            let p = path.field("chargingProfileCriteria");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearChargingProfileResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ClearChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for ClearChargingProfileResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearDisplayMessageRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Id of the message that SHALL be removed from the Charging Station.
    #[serde(rename = "id")]
    pub id: i64,
}

impl Validate for ClearDisplayMessageRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearDisplayMessageResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ClearMessageStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for ClearDisplayMessageResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearVariableMonitoringRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// List of the monitors to be cleared, identified by there Id.
    #[serde(rename = "id")]
    pub id: Vec<i64>,
}

impl Validate for ClearVariableMonitoringRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.id;
            let p = path.field("id");
            v::items(x, Some(1), None, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearVariableMonitoringResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "clearMonitoringResult")]
    pub clear_monitoring_result: Vec<ClearMonitoringResult>,
}

impl Validate for ClearVariableMonitoringResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.clear_monitoring_result;
            let p = path.field("clearMonitoringResult");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearedChargingLimitRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "chargingLimitSource")]
    pub charging_limit_source: ChargingLimitSourceEnum,
    /// EVSE Identifier.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
}

impl Validate for ClearedChargingLimitRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearedChargingLimitResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearedChargingLimitResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CostUpdatedRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Current total cost, based on the information known by the CSMS, of the transaction including taxes. In the currency configured with the configuration Variable: \[&lt;&lt;configkey-currency, Currency&gt;&gt;\]
    #[serde(rename = "totalCost")]
    pub total_cost: f64,
    /// Transaction Id of the transaction the current cost are asked for.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
}

impl Validate for CostUpdatedRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CostUpdatedResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CostUpdatedResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CustomerInformationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(
        rename = "customerCertificate",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub customer_certificate: Option<CertificateHashData>,
    #[serde(rename = "idToken", default, skip_serializing_if = "Option::is_none")]
    pub id_token: Option<IdToken>,
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// Flag indicating whether the Charging Station should return NotifyCustomerInformationRequest messages containing information about the customer referred to.
    #[serde(rename = "report")]
    pub report: bool,
    /// Flag indicating whether the Charging Station should clear all information about the customer referred to.
    #[serde(rename = "clear")]
    pub clear: bool,
    /// A (e.g. vendor specific) identifier of the customer this request refers to. This field contains a custom identifier other than IdToken and Certificate.
    /// One of the possible identifiers (customerIdentifier, customerIdToken or customerCertificate) should be in the request message.
    #[serde(
        rename = "customerIdentifier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub customer_identifier: Option<String>,
}

impl Validate for CustomerInformationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.customer_certificate {
            let p = path.field("customerCertificate");
            x.validate(&p)?;
        }
        if let Some(x) = &self.id_token {
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        if let Some(x) = &self.customer_identifier {
            let p = path.field("customerIdentifier");
            v::max_length(x, 64, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CustomerInformationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: CustomerInformationStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for CustomerInformationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DataTransferRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// May be used to indicate a specific message or implementation.
    #[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
    pub message_id: Option<String>,
    /// Data without specified length or format. This needs to be decided by both parties (Open to implementation).
    #[serde(rename = "data", default, skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_json::Value>,
    /// This identifies the Vendor specific implementation
    #[serde(rename = "vendorId")]
    pub vendor_id: String,
}

impl Validate for DataTransferRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.message_id {
            let p = path.field("messageId");
            v::max_length(x, 50, &p)?;
        }
        {
            let x = &self.vendor_id;
            let p = path.field("vendorId");
            v::max_length(x, 255, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DataTransferResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: DataTransferStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// Data without specified length or format, in response to request.
    #[serde(rename = "data", default, skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_json::Value>,
}

impl Validate for DataTransferResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DeleteCertificateRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "certificateHashData")]
    pub certificate_hash_data: CertificateHashData,
}

impl Validate for DeleteCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.certificate_hash_data;
            let p = path.field("certificateHashData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DeleteCertificateResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: DeleteCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for DeleteCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FirmwareStatusNotificationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: FirmwareStatusEnum,
    /// The request id that was provided in the
    /// UpdateFirmwareRequest that started this firmware update.
    /// This field is mandatory, unless the message was triggered by a TriggerMessageRequest AND there is no firmware update ongoing.
    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<i64>,
}

impl Validate for FirmwareStatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FirmwareStatusNotificationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for FirmwareStatusNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Get15118EVCertificateRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Schema version currently used for the 15118 session between EV and Charging Station. Needed for parsing of the EXI stream by the CSMS.
    #[serde(rename = "iso15118SchemaVersion")]
    pub iso15118_schema_version: String,
    #[serde(rename = "action")]
    pub action: CertificateActionEnum,
    /// Raw CertificateInstallationReq request from EV, Base64 encoded.
    #[serde(rename = "exiRequest")]
    pub exi_request: String,
}

impl Validate for Get15118EVCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.iso15118_schema_version;
            let p = path.field("iso15118SchemaVersion");
            v::max_length(x, 50, &p)?;
        }
        {
            let x = &self.exi_request;
            let p = path.field("exiRequest");
            v::max_length(x, 5600, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Get15118EVCertificateResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: Iso15118EVCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// Raw CertificateInstallationRes response for the EV, Base64 encoded.
    #[serde(rename = "exiResponse")]
    pub exi_response: String,
}

impl Validate for Get15118EVCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        {
            let x = &self.exi_response;
            let p = path.field("exiResponse");
            v::max_length(x, 5600, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetBaseReportRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(rename = "reportBase")]
    pub report_base: ReportBaseEnum,
}

impl Validate for GetBaseReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetBaseReportResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for GetBaseReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetCertificateStatusRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "ocspRequestData")]
    pub ocsp_request_data: OCSPRequestData,
}

impl Validate for GetCertificateStatusRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.ocsp_request_data;
            let p = path.field("ocspRequestData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetCertificateStatusResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GetCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// OCSPResponse class as defined in &lt;&lt;ref-ocpp_security_24, IETF RFC 6960&gt;&gt;. DER encoded (as defined in &lt;&lt;ref-ocpp_security_24, IETF RFC 6960&gt;&gt;), and then base64 encoded. MAY only be omitted when status is not Accepted.
    #[serde(
        rename = "ocspResult",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub ocsp_result: Option<String>,
}

impl Validate for GetCertificateStatusResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.ocsp_result {
            let p = path.field("ocspResult");
            v::max_length(x, 5500, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetChargingProfilesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Reference identification that is to be used by the Charging Station in the &lt;&lt;reportchargingprofilesrequest, ReportChargingProfilesRequest&gt;&gt; when provided.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// For which EVSE installed charging profiles SHALL be reported. If 0, only charging profiles installed on the Charging Station itself (the grid connection) SHALL be reported. If omitted, all installed charging profiles SHALL be reported.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(rename = "chargingProfile")]
    pub charging_profile: ChargingProfileCriterion,
}

impl Validate for GetChargingProfilesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.charging_profile;
            let p = path.field("chargingProfile");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetChargingProfilesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GetChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for GetChargingProfilesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetCompositeScheduleRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Length of the requested schedule in seconds.
    #[serde(rename = "duration")]
    pub duration: i64,
    #[serde(
        rename = "chargingRateUnit",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_rate_unit: Option<ChargingRateUnitEnum>,
    /// The ID of the EVSE for which the schedule is requested. When evseid=0, the Charging Station will calculate the expected consumption for the grid connection.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
}

impl Validate for GetCompositeScheduleRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetCompositeScheduleResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(rename = "schedule", default, skip_serializing_if = "Option::is_none")]
    pub schedule: Option<CompositeSchedule>,
}

impl Validate for GetCompositeScheduleResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.schedule {
            let p = path.field("schedule");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetDisplayMessagesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// If provided the Charging Station shall return Display Messages of the given ids. This field SHALL NOT contain more ids than set in &lt;&lt;configkey-number-of-display-messages,NumberOfDisplayMessages.maxLimit&gt;&gt;
    #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
    pub id: Option<Vec<i64>>,
    /// The Id of this request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(rename = "priority", default, skip_serializing_if = "Option::is_none")]
    pub priority: Option<MessagePriorityEnum>,
    #[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
    pub state: Option<MessageStateEnum>,
}

impl Validate for GetDisplayMessagesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.id {
            let p = path.field("id");
            v::items(x, Some(1), None, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetDisplayMessagesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GetDisplayMessagesStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for GetDisplayMessagesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetInstalledCertificateIdsRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Indicates the type of certificates requested. When omitted, all certificate types are requested.
    #[serde(
        rename = "certificateType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate_type: Option<Vec<GetCertificateIdUseEnum>>,
}

impl Validate for GetInstalledCertificateIdsRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.certificate_type {
            let p = path.field("certificateType");
            v::items(x, Some(1), None, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetInstalledCertificateIdsResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GetInstalledCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "certificateHashDataChain",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate_hash_data_chain: Option<Vec<CertificateHashDataChain>>,
}

impl Validate for GetInstalledCertificateIdsResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.certificate_hash_data_chain {
            let p = path.field("certificateHashDataChain");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetLocalListVersionRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetLocalListVersionRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetLocalListVersionResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// This contains the current version number of the local authorization list in the Charging Station.
    #[serde(rename = "versionNumber")]
    pub version_number: i64,
}

impl Validate for GetLocalListVersionResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetLogRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "log")]
    pub log: LogParameters,
    #[serde(rename = "logType")]
    pub log_type: LogEnum,
    /// The Id of this request
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// This specifies how many times the Charging Station must try to upload the log before giving up. If this field is not present, it is left to Charging Station to decide how many times it wants to retry.
    #[serde(rename = "retries", default, skip_serializing_if = "Option::is_none")]
    pub retries: Option<i64>,
    /// The interval in seconds after which a retry may be attempted. If this field is not present, it is left to Charging Station to decide how long to wait between attempts.
    #[serde(
        rename = "retryInterval",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_interval: Option<i64>,
}

impl Validate for GetLogRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.log;
            let p = path.field("log");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetLogResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: LogStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// This contains the name of the log file that will be uploaded. This field is not present when no logging information is available.
    #[serde(rename = "filename", default, skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
}

impl Validate for GetLogResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.filename {
            let p = path.field("filename");
            v::max_length(x, 255, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetMonitoringReportRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(
        rename = "componentVariable",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub component_variable: Option<Vec<ComponentVariable>>,
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// This field contains criteria for components for which a monitoring report is requested
    #[serde(
        rename = "monitoringCriteria",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub monitoring_criteria: Option<Vec<MonitoringCriterionEnum>>,
}

impl Validate for GetMonitoringReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.component_variable {
            let p = path.field("componentVariable");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.monitoring_criteria {
            let p = path.field("monitoringCriteria");
            v::items(x, Some(1), Some(3), &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetMonitoringReportResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for GetMonitoringReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetReportRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(
        rename = "componentVariable",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub component_variable: Option<Vec<ComponentVariable>>,
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// This field contains criteria for components for which a report is requested
    #[serde(
        rename = "componentCriteria",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub component_criteria: Option<Vec<ComponentCriterionEnum>>,
}

impl Validate for GetReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.component_variable {
            let p = path.field("componentVariable");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.component_criteria {
            let p = path.field("componentCriteria");
            v::items(x, Some(1), Some(4), &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetReportResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for GetReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetTransactionStatusRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The Id of the transaction for which the status is requested.
    #[serde(
        rename = "transactionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub transaction_id: Option<String>,
}

impl Validate for GetTransactionStatusRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.transaction_id {
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetTransactionStatusResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Whether the transaction is still ongoing.
    #[serde(
        rename = "ongoingIndicator",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub ongoing_indicator: Option<bool>,
    /// Whether there are still message to be delivered.
    #[serde(rename = "messagesInQueue")]
    pub messages_in_queue: bool,
}

impl Validate for GetTransactionStatusResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetVariablesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "getVariableData")]
    pub get_variable_data: Vec<GetVariableData>,
}

impl Validate for GetVariablesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.get_variable_data;
            let p = path.field("getVariableData");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetVariablesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "getVariableResult")]
    pub get_variable_result: Vec<GetVariableResult>,
}

impl Validate for GetVariablesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.get_variable_result;
            let p = path.field("getVariableResult");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HeartbeatRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for HeartbeatRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HeartbeatResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Contains the current time of the CSMS.
    #[serde(rename = "currentTime")]
    pub current_time: DateTime,
}

impl Validate for HeartbeatResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct InstallCertificateRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "certificateType")]
    pub certificate_type: InstallCertificateUseEnum,
    /// A PEM encoded X.509 certificate.
    #[serde(rename = "certificate")]
    pub certificate: String,
}

impl Validate for InstallCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.certificate;
            let p = path.field("certificate");
            v::max_length(x, 5500, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct InstallCertificateResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: InstallCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for InstallCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LogStatusNotificationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: UploadLogStatusEnum,
    /// The request id that was provided in GetLogRequest that started this log upload. This field is mandatory,
    /// unless the message was triggered by a TriggerMessageRequest AND there is no log upload ongoing.
    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<i64>,
}

impl Validate for LogStatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LogStatusNotificationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for LogStatusNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

/// Request_ Body
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MeterValuesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Request_ Body. EVSEID. Numeric_ Identifier
    /// This contains a number (&gt;0) designating an EVSE of the Charging Station. ‘0’ (zero) is used to designate the main power meter.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    #[serde(rename = "meterValue")]
    pub meter_value: Vec<MeterValue>,
}

impl Validate for MeterValuesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.meter_value;
            let p = path.field("meterValue");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MeterValuesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for MeterValuesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyChargingLimitRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(
        rename = "chargingSchedule",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_schedule: Option<Vec<ChargingSchedule>>,
    /// The charging schedule contained in this notification applies to an EVSE. evseId must be &gt; 0.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(rename = "chargingLimit")]
    pub charging_limit: ChargingLimit,
}

impl Validate for NotifyChargingLimitRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.charging_schedule {
            let p = path.field("chargingSchedule");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        {
            let x = &self.charging_limit;
            let p = path.field("chargingLimit");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyChargingLimitResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyChargingLimitResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyCustomerInformationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// (Part of) the requested data. No format specified in which the data is returned. Should be human readable.
    #[serde(rename = "data")]
    pub data: String,
    /// “to be continued” indicator. Indicates whether another part of the monitoringData follows in an upcoming notifyMonitoringReportRequest message. Default value when omitted is false.
    #[serde(rename = "tbc", default, skip_serializing_if = "Option::is_none")]
    pub tbc: Option<bool>,
    /// Sequence number of this message. First message starts at 0.
    #[serde(rename = "seqNo")]
    pub seq_no: i64,
    /// Timestamp of the moment this message was generated at the Charging Station.
    #[serde(rename = "generatedAt")]
    pub generated_at: DateTime,
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
}

impl Validate for NotifyCustomerInformationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.data;
            let p = path.field("data");
            v::max_length(x, 512, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyCustomerInformationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyCustomerInformationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyDisplayMessagesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(
        rename = "messageInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub message_info: Option<Vec<MessageInfo>>,
    /// The id of the &lt;&lt;getdisplaymessagesrequest,GetDisplayMessagesRequest&gt;&gt; that requested this message.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// "to be continued" indicator. Indicates whether another part of the report follows in an upcoming NotifyDisplayMessagesRequest message. Default value when omitted is false.
    #[serde(rename = "tbc", default, skip_serializing_if = "Option::is_none")]
    pub tbc: Option<bool>,
}

impl Validate for NotifyDisplayMessagesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.message_info {
            let p = path.field("messageInfo");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyDisplayMessagesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyDisplayMessagesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyEVChargingNeedsRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Contains the maximum schedule tuples the car supports per schedule.
    #[serde(
        rename = "maxScheduleTuples",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub max_schedule_tuples: Option<i64>,
    #[serde(rename = "chargingNeeds")]
    pub charging_needs: ChargingNeeds,
    /// Defines the EVSE and connector to which the EV is connected. EvseId may not be 0.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
}

impl Validate for NotifyEVChargingNeedsRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.charging_needs;
            let p = path.field("chargingNeeds");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyEVChargingNeedsResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: NotifyEVChargingNeedsStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for NotifyEVChargingNeedsResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyEVChargingScheduleRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Periods contained in the charging profile are relative to this point in time.
    #[serde(rename = "timeBase")]
    pub time_base: DateTime,
    #[serde(rename = "chargingSchedule")]
    pub charging_schedule: ChargingSchedule,
    /// The charging schedule contained in this notification applies to an EVSE. EvseId must be &gt; 0.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
}

impl Validate for NotifyEVChargingScheduleRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.charging_schedule;
            let p = path.field("chargingSchedule");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyEVChargingScheduleResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for NotifyEVChargingScheduleResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyEventRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Timestamp of the moment this message was generated at the Charging Station.
    #[serde(rename = "generatedAt")]
    pub generated_at: DateTime,
    /// “to be continued” indicator. Indicates whether another part of the report follows in an upcoming notifyEventRequest message. Default value when omitted is false.
    #[serde(rename = "tbc", default, skip_serializing_if = "Option::is_none")]
    pub tbc: Option<bool>,
    /// Sequence number of this message. First message starts at 0.
    #[serde(rename = "seqNo")]
    pub seq_no: i64,
    #[serde(rename = "eventData")]
    pub event_data: Vec<EventData>,
}

impl Validate for NotifyEventRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.event_data;
            let p = path.field("eventData");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyEventResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyEventResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyMonitoringReportRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "monitor", default, skip_serializing_if = "Option::is_none")]
    pub monitor: Option<Vec<MonitoringData>>,
    /// The id of the GetMonitoringRequest that requested this report.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// “to be continued” indicator. Indicates whether another part of the monitoringData follows in an upcoming notifyMonitoringReportRequest message. Default value when omitted is false.
    #[serde(rename = "tbc", default, skip_serializing_if = "Option::is_none")]
    pub tbc: Option<bool>,
    /// Sequence number of this message. First message starts at 0.
    #[serde(rename = "seqNo")]
    pub seq_no: i64,
    /// Timestamp of the moment this message was generated at the Charging Station.
    #[serde(rename = "generatedAt")]
    pub generated_at: DateTime,
}

impl Validate for NotifyMonitoringReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.monitor {
            let p = path.field("monitor");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyMonitoringReportResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyMonitoringReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyReportRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The id of the GetReportRequest  or GetBaseReportRequest that requested this report
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// Timestamp of the moment this message was generated at the Charging Station.
    #[serde(rename = "generatedAt")]
    pub generated_at: DateTime,
    #[serde(
        rename = "reportData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub report_data: Option<Vec<ReportData>>,
    /// “to be continued” indicator. Indicates whether another part of the report follows in an upcoming notifyReportRequest message. Default value when omitted is false.
    #[serde(rename = "tbc", default, skip_serializing_if = "Option::is_none")]
    pub tbc: Option<bool>,
    /// Sequence number of this message. First message starts at 0.
    #[serde(rename = "seqNo")]
    pub seq_no: i64,
}

impl Validate for NotifyReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.report_data {
            let p = path.field("reportData");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyReportResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PublishFirmwareRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// This contains a string containing a URI pointing to a
    /// location from which to retrieve the firmware.
    #[serde(rename = "location")]
    pub location: String,
    /// This specifies how many times Charging Station must try
    /// to download the firmware before giving up. If this field is not
    /// present, it is left to Charging Station to decide how many times it wants to retry.
    #[serde(rename = "retries", default, skip_serializing_if = "Option::is_none")]
    pub retries: Option<i64>,
    /// The MD5 checksum over the entire firmware file as a hexadecimal string of length 32.
    #[serde(rename = "checksum")]
    pub checksum: String,
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// The interval in seconds
    /// after which a retry may be
    /// attempted. If this field is not
    /// present, it is left to Charging
    /// Station to decide how long to wait
    /// between attempts.
    #[serde(
        rename = "retryInterval",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_interval: Option<i64>,
}

impl Validate for PublishFirmwareRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.location;
            let p = path.field("location");
            v::max_length(x, 512, &p)?;
        }
        {
            let x = &self.checksum;
            let p = path.field("checksum");
            v::max_length(x, 32, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PublishFirmwareResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for PublishFirmwareResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PublishFirmwareStatusNotificationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: PublishFirmwareStatusEnum,
    /// Required if status is Published. Can be multiple URI’s, if the Local Controller supports e.g. HTTP, HTTPS, and FTP.
    #[serde(rename = "location", default, skip_serializing_if = "Option::is_none")]
    pub location: Option<Vec<String>>,
    /// The request id that was
    /// provided in the
    /// PublishFirmwareRequest which
    /// triggered this action.
    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<i64>,
}

impl Validate for PublishFirmwareStatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.location {
            let p = path.field("location");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 512, &p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PublishFirmwareStatusNotificationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for PublishFirmwareStatusNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReportChargingProfilesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Id used to match the &lt;&lt;getchargingprofilesrequest, GetChargingProfilesRequest&gt;&gt; message with the resulting ReportChargingProfilesRequest messages. When the CSMS provided a requestId in the &lt;&lt;getchargingprofilesrequest, GetChargingProfilesRequest&gt;&gt;, this field SHALL contain the same value.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(rename = "chargingLimitSource")]
    pub charging_limit_source: ChargingLimitSourceEnum,
    #[serde(rename = "chargingProfile")]
    pub charging_profile: Vec<ChargingProfile>,
    /// To Be Continued. Default value when omitted: false. false indicates that there are no further messages as part of this report.
    #[serde(rename = "tbc", default, skip_serializing_if = "Option::is_none")]
    pub tbc: Option<bool>,
    /// The evse to which the charging profile applies. If evseId = 0, the message contains an overall limit for the Charging Station.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
}

impl Validate for ReportChargingProfilesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.charging_profile;
            let p = path.field("chargingProfile");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReportChargingProfilesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReportChargingProfilesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RequestStartTransactionRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Number of the EVSE on which to start the transaction. EvseId SHALL be &gt; 0
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(
        rename = "groupIdToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub group_id_token: Option<IdToken>,
    #[serde(rename = "idToken")]
    pub id_token: IdToken,
    /// Id given by the server to this start request. The Charging Station might return this in the &lt;&lt;transactioneventrequest, TransactionEventRequest&gt;&gt;, letting the server know which transaction was started for this request. Use to start a transaction.
    #[serde(rename = "remoteStartId")]
    pub remote_start_id: i64,
    #[serde(
        rename = "chargingProfile",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_profile: Option<ChargingProfile>,
}

impl Validate for RequestStartTransactionRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.group_id_token {
            let p = path.field("groupIdToken");
            x.validate(&p)?;
        }
        {
            let x = &self.id_token;
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        if let Some(x) = &self.charging_profile {
            let p = path.field("chargingProfile");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RequestStartTransactionResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: RequestStartStopStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// When the transaction was already started by the Charging Station before the RequestStartTransactionRequest was received, for example: cable plugged in first. This contains the transactionId of the already started transaction.
    #[serde(
        rename = "transactionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub transaction_id: Option<String>,
}

impl Validate for RequestStartTransactionResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.transaction_id {
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RequestStopTransactionRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The identifier of the transaction which the Charging Station is requested to stop.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
}

impl Validate for RequestStopTransactionRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RequestStopTransactionResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: RequestStartStopStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for RequestStopTransactionResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReservationStatusUpdateRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The ID of the reservation.
    #[serde(rename = "reservationId")]
    pub reservation_id: i64,
    #[serde(rename = "reservationUpdateStatus")]
    pub reservation_update_status: ReservationUpdateStatusEnum,
}

impl Validate for ReservationStatusUpdateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReservationStatusUpdateResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReservationStatusUpdateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReserveNowRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Id of reservation.
    #[serde(rename = "id")]
    pub id: i64,
    /// Date and time at which the reservation expires.
    #[serde(rename = "expiryDateTime")]
    pub expiry_date_time: DateTime,
    #[serde(
        rename = "connectorType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub connector_type: Option<ConnectorEnum>,
    #[serde(rename = "idToken")]
    pub id_token: IdToken,
    /// This contains ID of the evse to be reserved.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(
        rename = "groupIdToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub group_id_token: Option<IdToken>,
}

impl Validate for ReserveNowRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.id_token;
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        if let Some(x) = &self.group_id_token {
            let p = path.field("groupIdToken");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReserveNowResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ReserveNowStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for ReserveNowResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ResetRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "type")]
    pub r#type: ResetEnum,
    /// This contains the ID of a specific EVSE that needs to be reset, instead of the entire Charging Station.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
}

impl Validate for ResetRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ResetResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ResetStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for ResetResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SecurityEventNotificationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Type of the security event. This value should be taken from the Security events list.
    #[serde(rename = "type")]
    pub r#type: String,
    /// Date and time at which the event occurred.
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    /// Additional information about the occurred security event.
    #[serde(rename = "techInfo", default, skip_serializing_if = "Option::is_none")]
    pub tech_info: Option<String>,
}

impl Validate for SecurityEventNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.r#type;
            let p = path.field("type");
            v::max_length(x, 50, &p)?;
        }
        if let Some(x) = &self.tech_info {
            let p = path.field("techInfo");
            v::max_length(x, 255, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SecurityEventNotificationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SecurityEventNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SendLocalListRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(
        rename = "localAuthorizationList",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub local_authorization_list: Option<Vec<AuthorizationData>>,
    /// In case of a full update this is the version number of the full list. In case of a differential update it is the version number of the list after the update has been applied.
    #[serde(rename = "versionNumber")]
    pub version_number: i64,
    #[serde(rename = "updateType")]
    pub update_type: UpdateEnum,
}

impl Validate for SendLocalListRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.local_authorization_list {
            let p = path.field("localAuthorizationList");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SendLocalListResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: SendLocalListStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SendLocalListResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetChargingProfileRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// For TxDefaultProfile an evseId=0 applies the profile to each individual evse. For ChargingStationMaxProfile and ChargingStationExternalConstraints an evseId=0 contains an overal limit for the whole Charging Station.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    #[serde(rename = "chargingProfile")]
    pub charging_profile: ChargingProfile,
}

impl Validate for SetChargingProfileRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.charging_profile;
            let p = path.field("chargingProfile");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetChargingProfileResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: ChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SetChargingProfileResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetDisplayMessageRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "message")]
    pub message: MessageInfo,
}

impl Validate for SetDisplayMessageRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.message;
            let p = path.field("message");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetDisplayMessageResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: DisplayMessageStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SetDisplayMessageResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetMonitoringBaseRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "monitoringBase")]
    pub monitoring_base: MonitoringBaseEnum,
}

impl Validate for SetMonitoringBaseRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetMonitoringBaseResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SetMonitoringBaseResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetMonitoringLevelRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The Charging Station SHALL only report events with a severity number lower than or equal to this severity.
    /// The severity range is 0-9, with 0 as the highest and 9 as the lowest severity level.
    /// The severity levels have the following meaning: +
    /// *0-Danger* +
    /// Indicates lives are potentially in danger. Urgent attention is needed and action should be taken immediately. +
    /// *1-Hardware Failure* +
    /// Indicates that the Charging Station is unable to continue regular operations due to Hardware issues. Action is required. +
    /// *2-System Failure* +
    /// Indicates that the Charging Station is unable to continue regular operations due to software or minor hardware issues. Action is required. +
    /// *3-Critical* +
    /// Indicates a critical error. Action is required. +
    /// *4-Error* +
    /// Indicates a non-urgent error. Action is required. +
    /// *5-Alert* +
    /// Indicates an alert event. Default severity for any type of monitoring event.  +
    /// *6-Warning* +
    /// Indicates a warning event. Action may be required. +
    /// *7-Notice* +
    /// Indicates an unusual event. No immediate action is required. +
    /// *8-Informational* +
    /// Indicates a regular operational event. May be used for reporting, measuring throughput, etc. No action is required. +
    /// *9-Debug* +
    /// Indicates information useful to developers for debugging, not useful during operations.
    #[serde(rename = "severity")]
    pub severity: i64,
}

impl Validate for SetMonitoringLevelRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetMonitoringLevelResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SetMonitoringLevelResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetNetworkProfileRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// Slot in which the configuration should be stored.
    #[serde(rename = "configurationSlot")]
    pub configuration_slot: i64,
    #[serde(rename = "connectionData")]
    pub connection_data: NetworkConnectionProfile,
}

impl Validate for SetNetworkProfileRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.connection_data;
            let p = path.field("connectionData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetNetworkProfileResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: SetNetworkProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SetNetworkProfileResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetVariableMonitoringRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "setMonitoringData")]
    pub set_monitoring_data: Vec<SetMonitoringData>,
}

impl Validate for SetVariableMonitoringRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.set_monitoring_data;
            let p = path.field("setMonitoringData");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetVariableMonitoringResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "setMonitoringResult")]
    pub set_monitoring_result: Vec<SetMonitoringResult>,
}

impl Validate for SetVariableMonitoringResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.set_monitoring_result;
            let p = path.field("setMonitoringResult");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetVariablesRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "setVariableData")]
    pub set_variable_data: Vec<SetVariableData>,
}

impl Validate for SetVariablesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.set_variable_data;
            let p = path.field("setVariableData");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetVariablesResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "setVariableResult")]
    pub set_variable_result: Vec<SetVariableResult>,
}

impl Validate for SetVariablesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.set_variable_result;
            let p = path.field("setVariableResult");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SignCertificateRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The Charging Station SHALL send the public key in form of a Certificate Signing Request (CSR) as described in RFC 2986 \[22\] and then PEM encoded, using the &lt;&lt;signcertificaterequest,SignCertificateRequest&gt;&gt; message.
    #[serde(rename = "csr")]
    pub csr: String,
    #[serde(
        rename = "certificateType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate_type: Option<CertificateSigningUseEnum>,
}

impl Validate for SignCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.csr;
            let p = path.field("csr");
            v::max_length(x, 5500, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SignCertificateResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for SignCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StatusNotificationRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The time for which the status is reported. If absent time of receipt of the message will be assumed.
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    #[serde(rename = "connectorStatus")]
    pub connector_status: ConnectorStatusEnum,
    /// The id of the EVSE to which the connector belongs for which the the status is reported.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    /// The id of the connector within the EVSE for which the status is reported.
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
}

impl Validate for StatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StatusNotificationResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for StatusNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionEventRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "eventType")]
    pub event_type: TransactionEventEnum,
    #[serde(
        rename = "meterValue",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub meter_value: Option<Vec<MeterValue>>,
    /// The date and time at which this transaction event occurred.
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    #[serde(rename = "triggerReason")]
    pub trigger_reason: TriggerReasonEnum,
    /// Incremental sequence number, helps with determining if all messages of a transaction have been received.
    #[serde(rename = "seqNo")]
    pub seq_no: i64,
    /// Indication that this transaction event happened when the Charging Station was offline. Default = false, meaning: the event occurred when the Charging Station was online.
    #[serde(rename = "offline", default, skip_serializing_if = "Option::is_none")]
    pub offline: Option<bool>,
    /// If the Charging Station is able to report the number of phases used, then it SHALL provide it. When omitted the CSMS may be able to determine the number of phases used via device management.
    #[serde(
        rename = "numberOfPhasesUsed",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub number_of_phases_used: Option<i64>,
    /// The maximum current of the connected cable in Ampere (A).
    #[serde(
        rename = "cableMaxCurrent",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub cable_max_current: Option<i64>,
    /// This contains the Id of the reservation that terminates as a result of this transaction.
    #[serde(
        rename = "reservationId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub reservation_id: Option<i64>,
    #[serde(rename = "transactionInfo")]
    pub transaction_info: Transaction,
    #[serde(rename = "evse", default, skip_serializing_if = "Option::is_none")]
    pub evse: Option<EVSE>,
    #[serde(rename = "idToken", default, skip_serializing_if = "Option::is_none")]
    pub id_token: Option<IdToken>,
}

impl Validate for TransactionEventRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.meter_value {
            let p = path.field("meterValue");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        {
            let x = &self.transaction_info;
            let p = path.field("transactionInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.evse {
            let p = path.field("evse");
            x.validate(&p)?;
        }
        if let Some(x) = &self.id_token {
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionEventResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// SHALL only be sent when charging has ended. Final total cost of this transaction, including taxes. In the currency configured with the Configuration Variable: &lt;&lt;configkey-currency,`Currency`&gt;&gt;. When omitted, the transaction was NOT free. To indicate a free transaction, the CSMS SHALL send 0.00.
    #[serde(rename = "totalCost", default, skip_serializing_if = "Option::is_none")]
    pub total_cost: Option<f64>,
    /// Priority from a business point of view. Default priority is 0, The range is from -9 to 9. Higher values indicate a higher priority. The chargingPriority in &lt;&lt;transactioneventresponse,TransactionEventResponse&gt;&gt; is temporarily, so it may not be set in the &lt;&lt;cmn_idtokeninfotype,IdTokenInfoType&gt;&gt; afterwards. Also the chargingPriority in &lt;&lt;transactioneventresponse,TransactionEventResponse&gt;&gt; overrules the one in &lt;&lt;cmn_idtokeninfotype,IdTokenInfoType&gt;&gt;.
    #[serde(
        rename = "chargingPriority",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_priority: Option<i64>,
    #[serde(
        rename = "idTokenInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub id_token_info: Option<IdTokenInfo>,
    #[serde(
        rename = "updatedPersonalMessage",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub updated_personal_message: Option<MessageContent>,
}

impl Validate for TransactionEventResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.id_token_info {
            let p = path.field("idTokenInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.updated_personal_message {
            let p = path.field("updatedPersonalMessage");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TriggerMessageRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "evse", default, skip_serializing_if = "Option::is_none")]
    pub evse: Option<EVSE>,
    #[serde(rename = "requestedMessage")]
    pub requested_message: MessageTriggerEnum,
}

impl Validate for TriggerMessageRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.evse {
            let p = path.field("evse");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TriggerMessageResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: TriggerMessageStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for TriggerMessageResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnlockConnectorRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// This contains the identifier of the EVSE for which a connector needs to be unlocked.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    /// This contains the identifier of the connector that needs to be unlocked.
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
}

impl Validate for UnlockConnectorRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnlockConnectorResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: UnlockStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for UnlockConnectorResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnpublishFirmwareRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// The MD5 checksum over the entire firmware file as a hexadecimal string of length 32.
    #[serde(rename = "checksum")]
    pub checksum: String,
}

impl Validate for UnpublishFirmwareRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.checksum;
            let p = path.field("checksum");
            v::max_length(x, 32, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnpublishFirmwareResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: UnpublishFirmwareStatusEnum,
}

impl Validate for UnpublishFirmwareResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UpdateFirmwareRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    /// This specifies how many times Charging Station must try to download the firmware before giving up. If this field is not present, it is left to Charging Station to decide how many times it wants to retry.
    #[serde(rename = "retries", default, skip_serializing_if = "Option::is_none")]
    pub retries: Option<i64>,
    /// The interval in seconds after which a retry may be attempted. If this field is not present, it is left to Charging Station to decide how long to wait between attempts.
    #[serde(
        rename = "retryInterval",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_interval: Option<i64>,
    /// The Id of this request
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(rename = "firmware")]
    pub firmware: Firmware,
}

impl Validate for UpdateFirmwareRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        {
            let x = &self.firmware;
            let p = path.field("firmware");
            x.validate(&p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UpdateFirmwareResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
    #[serde(rename = "status")]
    pub status: UpdateFirmwareStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
}

impl Validate for UpdateFirmwareResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        Ok(())
    }
}