codetics_ocpp21/

messages.rs

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

//! OCPP 2.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 AFRRSignalRequest {
    /// Time when signal becomes active.
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    /// Value of signal in _v2xSignalWattCurve_.
    #[serde(rename = "signal")]
    pub signal: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for AFRRSignalRequest {
    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 AFRRSignalResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for AFRRSignalResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 AdjustPeriodicEventStreamRequest {
    #[serde(rename = "id")]
    pub id: i64,
    #[serde(rename = "params")]
    pub params: PeriodicEventStreamParams,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for AdjustPeriodicEventStreamRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id;
            let p = path.field("id");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.params;
            let p = path.field("params");
            x.validate(&p)?;
        }
        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 AdjustPeriodicEventStreamResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for AdjustPeriodicEventStreamResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 AuthorizeRequest {
    #[serde(rename = "idToken")]
    pub id_token: IdToken,
    /// *(2.1)* The X.509 certificate chain presented by EV and encoded in PEM format. Order of certificates in chain is from leaf up to (but excluding) root certificate. +
    /// Only needed in case of central contract validation when Charging Station cannot validate the contract certificate.
    #[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>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for AuthorizeRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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, 10000, &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)?;
            }
        }
        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 AuthorizeResponse {
    #[serde(rename = "idTokenInfo")]
    pub id_token_info: IdTokenInfo,
    #[serde(
        rename = "certificateStatus",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub certificate_status: Option<AuthorizeCertificateStatusEnum>,
    /// *(2.1)* List of allowed energy transfer modes the EV can choose from. If omitted this defaults to charging only.
    #[serde(
        rename = "allowedEnergyTransfer",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub allowed_energy_transfer: Option<Vec<EnergyTransferModeEnum>>,
    #[serde(rename = "tariff", default, skip_serializing_if = "Option::is_none")]
    pub tariff: Option<Tariff>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for AuthorizeResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id_token_info;
            let p = path.field("idTokenInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.allowed_energy_transfer {
            let p = path.field("allowedEnergyTransfer");
            v::items(x, Some(1), None, &p)?;
        }
        if let Some(x) = &self.tariff {
            let p = path.field("tariff");
            x.validate(&p)?;
        }
        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 BatterySwapRequest {
    #[serde(rename = "batteryData")]
    pub battery_data: Vec<BatteryData>,
    #[serde(rename = "eventType")]
    pub event_type: BatterySwapEventEnum,
    #[serde(rename = "idToken")]
    pub id_token: IdToken,
    /// RequestId to correlate BatteryIn/Out events and optional RequestBatterySwapRequest.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for BatterySwapRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.battery_data;
            let p = path.field("batteryData");
            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.id_token;
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

/// This is an empty response that just acknowledges receipt of the request. (The request cannot be rejected).
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BatterySwapResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for BatterySwapResponse {
    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 BootNotificationRequest {
    #[serde(rename = "chargingStation")]
    pub charging_station: ChargingStation,
    #[serde(rename = "reason")]
    pub reason: BootReasonEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for BootNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.charging_station;
            let p = path.field("chargingStation");
            x.validate(&p)?;
        }
        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 BootNotificationResponse {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for BootNotificationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 CancelReservationRequest {
    /// Id of the reservation to cancel.
    #[serde(rename = "reservationId")]
    pub reservation_id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CancelReservationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.reservation_id;
            let p = path.field("reservationId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "status")]
    pub status: CancelReservationStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CancelReservationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 CertificateSignedRequest {
    /// The signed PEM encoded X.509 certificate. This SHALL also contain the necessary sub CA certificates, when applicable. The order of the bundle follows 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>,
    /// *(2.1)* RequestId to correlate this message with the SignCertificateRequest.
    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<i64>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CertificateSignedRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.certificate_chain;
            let p = path.field("certificateChain");
            v::max_length(x, 10000, &p)?;
        }
        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 CertificateSignedResponse {
    #[serde(rename = "status")]
    pub status: CertificateSignedStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CertificateSignedResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ChangeAvailabilityRequest {
    #[serde(rename = "evse", default, skip_serializing_if = "Option::is_none")]
    pub evse: Option<EVSE>,
    #[serde(rename = "operationalStatus")]
    pub operational_status: OperationalStatusEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ChangeAvailabilityRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.evse {
            let p = path.field("evse");
            x.validate(&p)?;
        }
        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 ChangeAvailabilityResponse {
    #[serde(rename = "status")]
    pub status: ChangeAvailabilityStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ChangeAvailabilityResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ChangeTransactionTariffRequest {
    #[serde(rename = "tariff")]
    pub tariff: Tariff,
    /// Transaction id for new tariff.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ChangeTransactionTariffRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.tariff;
            let p = path.field("tariff");
            x.validate(&p)?;
        }
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        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 ChangeTransactionTariffResponse {
    #[serde(rename = "status")]
    pub status: TariffChangeStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ChangeTransactionTariffResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 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 = "status")]
    pub status: ClearCacheStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearCacheResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ClearChargingProfileRequest {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearChargingProfileRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.charging_profile_criteria {
            let p = path.field("chargingProfileCriteria");
            x.validate(&p)?;
        }
        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 ClearChargingProfileResponse {
    #[serde(rename = "status")]
    pub status: ClearChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearChargingProfileResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ClearDERControlRequest {
    /// True: clearing default DER controls. False: clearing scheduled controls.
    #[serde(rename = "isDefault")]
    pub is_default: bool,
    #[serde(
        rename = "controlType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub control_type: Option<DERControlEnum>,
    /// Id of control setting to clear. When omitted all settings for _controlType_ are cleared.
    #[serde(rename = "controlId", default, skip_serializing_if = "Option::is_none")]
    pub control_id: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearDERControlRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.control_id {
            let p = path.field("controlId");
            v::max_length(x, 36, &p)?;
        }
        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 ClearDERControlResponse {
    #[serde(rename = "status")]
    pub status: DERControlStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearDERControlResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ClearDisplayMessageRequest {
    /// Id of the message that SHALL be removed from the Charging Station.
    #[serde(rename = "id")]
    pub id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearDisplayMessageRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id;
            let p = path.field("id");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "status")]
    pub status: ClearMessageStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearDisplayMessageResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ClearTariffsRequest {
    /// List of tariff Ids to clear. When absent clears all tariffs at _evseId_.
    #[serde(rename = "tariffIds", default, skip_serializing_if = "Option::is_none")]
    pub tariff_ids: Option<Vec<String>>,
    /// When present only clear tariffs matching _tariffIds_ at EVSE _evseId_.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearTariffsRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.tariff_ids {
            let p = path.field("tariffIds");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 60, &p0)?;
            }
        }
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 ClearTariffsResponse {
    #[serde(rename = "clearTariffsResult")]
    pub clear_tariffs_result: Vec<ClearTariffsResult>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearTariffsResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.clear_tariffs_result;
            let p = path.field("clearTariffsResult");
            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.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

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

impl Validate for ClearVariableMonitoringRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id;
            let p = path.field("id");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::minimum(*it0, 0i64, &p0)?;
            }
        }
        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 ClearVariableMonitoringResponse {
    #[serde(rename = "clearMonitoringResult")]
    pub clear_monitoring_result: Vec<ClearMonitoringResult>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearVariableMonitoringResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 ClearedChargingLimitRequest {
    /// Source of the charging limit. Allowed values defined in Appendix as ChargingLimitSourceEnumStringType.
    #[serde(rename = "chargingLimitSource")]
    pub charging_limit_source: String,
    /// EVSE Identifier.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClearedChargingLimitRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.charging_limit_source;
            let p = path.field("chargingLimitSource");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 ClosePeriodicEventStreamRequest {
    /// Id of stream to close.
    #[serde(rename = "id")]
    pub id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClosePeriodicEventStreamRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id;
            let p = path.field("id");
            v::minimum(*x, 0i64, &p)?;
        }
        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 ClosePeriodicEventStreamResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ClosePeriodicEventStreamResponse {
    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 {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CostUpdatedRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        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 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 = "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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CustomerInformationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        {
            let x = &self.request_id;
            let p = path.field("requestId");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.customer_identifier {
            let p = path.field("customerIdentifier");
            v::max_length(x, 64, &p)?;
        }
        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 CustomerInformationResponse {
    #[serde(rename = "status")]
    pub status: CustomerInformationStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for CustomerInformationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 DataTransferRequest {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for DataTransferRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        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 DataTransferResponse {
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for DataTransferResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 DeleteCertificateRequest {
    #[serde(rename = "certificateHashData")]
    pub certificate_hash_data: CertificateHashData,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for DeleteCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.certificate_hash_data;
            let p = path.field("certificateHashData");
            x.validate(&p)?;
        }
        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 DeleteCertificateResponse {
    #[serde(rename = "status")]
    pub status: DeleteCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for DeleteCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 FirmwareStatusNotificationRequest {
    #[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>,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for FirmwareStatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 {
    /// 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,
    /// *(2.1)* Raw CertificateInstallationReq request from EV, Base64 encoded. +
    /// Extended to support ISO 15118-20 certificates. The minimum supported length is 11000. If a longer _exiRequest_ is supported, then the supported length must be communicated in variable OCPPCommCtrlr.FieldLength\[ "Get15118EVCertificateRequest.exiRequest" \].
    #[serde(rename = "exiRequest")]
    pub exi_request: String,
    /// *(2.1)* Absent during ISO 15118-2 session. Required during ISO 15118-20 session. +
    /// Maximum number of contracts that EV wants to install.
    #[serde(
        rename = "maximumContractCertificateChains",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub maximum_contract_certificate_chains: Option<i64>,
    /// *(2.1)*  Absent during ISO 15118-2 session. Optional during ISO 15118-20 session. List of EMAIDs for which contract certificates must be requested first, in case there are more certificates than allowed by _maximumContractCertificateChains_.
    #[serde(
        rename = "prioritizedEMAIDs",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub prioritized_emai_ds: Option<Vec<String>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for Get15118EVCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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, 11000, &p)?;
        }
        if let Some(x) = &self.maximum_contract_certificate_chains {
            let p = path.field("maximumContractCertificateChains");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.prioritized_emai_ds {
            let p = path.field("prioritizedEMAIDs");
            v::items(x, Some(1), Some(8), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 255, &p0)?;
            }
        }
        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 Get15118EVCertificateResponse {
    #[serde(rename = "status")]
    pub status: Iso15118EVCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// *(2/1)* Raw CertificateInstallationRes response for the EV, Base64 encoded. +
    /// Extended to support ISO 15118-20 certificates. The minimum supported length is 17000. If a longer _exiResponse_ is supported, then the supported length must be communicated in variable OCPPCommCtrlr.FieldLength\[ "Get15118EVCertificateResponse.exiResponse" \].
    #[serde(rename = "exiResponse")]
    pub exi_response: String,
    /// *(2.1)* Number of contracts that can be retrieved with additional requests.
    #[serde(
        rename = "remainingContracts",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remaining_contracts: Option<i64>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for Get15118EVCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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, 17000, &p)?;
        }
        if let Some(x) = &self.remaining_contracts {
            let p = path.field("remainingContracts");
            v::minimum(*x, 0i64, &p)?;
        }
        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 GetBaseReportRequest {
    /// The Id of the request.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(rename = "reportBase")]
    pub report_base: ReportBaseEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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 = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetBaseReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 GetCertificateChainStatusRequest {
    #[serde(rename = "certificateStatusRequests")]
    pub certificate_status_requests: Vec<CertificateStatusRequestInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetCertificateChainStatusRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.certificate_status_requests;
            let p = path.field("certificateStatusRequests");
            v::items(x, Some(1), Some(4), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        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 GetCertificateChainStatusResponse {
    #[serde(rename = "certificateStatus")]
    pub certificate_status: Vec<CertificateStatus>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetCertificateChainStatusResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.certificate_status;
            let p = path.field("certificateStatus");
            v::items(x, Some(1), Some(4), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        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 GetCertificateStatusRequest {
    #[serde(rename = "ocspRequestData")]
    pub ocsp_request_data: OCSPRequestData,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetCertificateStatusRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.ocsp_request_data;
            let p = path.field("ocspRequestData");
            x.validate(&p)?;
        }
        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 GetCertificateStatusResponse {
    #[serde(rename = "status")]
    pub status: GetCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// *(2.1)* 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. +
    /// The minimum supported length is 18000. If a longer _ocspResult_ is supported, then the supported length must be communicated in variable OCPPCommCtrlr.FieldLength\[ "GetCertificateStatusResponse.ocspResult" \].
    #[serde(
        rename = "ocspResult",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub ocsp_result: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetCertificateStatusResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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, 18000, &p)?;
        }
        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 GetChargingProfilesRequest {
    /// 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. +
    /// Reported charging profiles SHALL match the criteria in field _chargingProfile_.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(rename = "chargingProfile")]
    pub charging_profile: ChargingProfileCriterion,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetChargingProfilesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.charging_profile;
            let p = path.field("chargingProfile");
            x.validate(&p)?;
        }
        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 GetChargingProfilesResponse {
    #[serde(rename = "status")]
    pub status: GetChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetChargingProfilesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 GetCompositeScheduleRequest {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetCompositeScheduleRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetCompositeScheduleResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        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 GetDERControlRequest {
    /// RequestId to be used in ReportDERControlRequest.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// True: get a default DER control. False: get a scheduled control.
    #[serde(rename = "isDefault", default, skip_serializing_if = "Option::is_none")]
    pub is_default: Option<bool>,
    #[serde(
        rename = "controlType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub control_type: Option<DERControlEnum>,
    /// Id of setting to get. When omitted all settings for _controlType_ are retrieved.
    #[serde(rename = "controlId", default, skip_serializing_if = "Option::is_none")]
    pub control_id: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetDERControlRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.control_id {
            let p = path.field("controlId");
            v::max_length(x, 36, &p)?;
        }
        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 GetDERControlResponse {
    #[serde(rename = "status")]
    pub status: DERControlStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetDERControlResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 GetDisplayMessagesRequest {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetDisplayMessagesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.id {
            let p = path.field("id");
            v::items(x, Some(1), None, &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::minimum(*it0, 0i64, &p0)?;
            }
        }
        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 GetDisplayMessagesResponse {
    #[serde(rename = "status")]
    pub status: GetDisplayMessagesStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetDisplayMessagesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 GetInstalledCertificateIdsRequest {
    /// 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>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetInstalledCertificateIdsRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.certificate_type {
            let p = path.field("certificateType");
            v::items(x, Some(1), None, &p)?;
        }
        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 GetInstalledCertificateIdsResponse {
    #[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>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetInstalledCertificateIdsResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
            }
        }
        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 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 {
    /// This contains the current version number of the local authorization list in the Charging Station.
    #[serde(rename = "versionNumber")]
    pub version_number: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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 = "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 retry 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. If the value is 0, it means: no retries.
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetLogRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.log;
            let p = path.field("log");
            x.validate(&p)?;
        }
        if let Some(x) = &self.retries {
            let p = path.field("retries");
            v::minimum(*x, 0i64, &p)?;
        }
        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 GetLogResponse {
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetLogResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        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 GetMonitoringReportRequest {
    #[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>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetMonitoringReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        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 GetMonitoringReportResponse {
    #[serde(rename = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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

/// This message is empty. It has no fields.
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetPeriodicEventStreamRequest {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetPeriodicEventStreamRequest {
    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 GetPeriodicEventStreamResponse {
    #[serde(
        rename = "constantStreamData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub constant_stream_data: Option<Vec<ConstantStreamData>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetReportRequest {
    #[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>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        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 GetReportResponse {
    #[serde(rename = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetReportResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 GetTariffsRequest {
    /// EVSE id to get tariff from. When _evseId_ = 0, this gets tariffs from all EVSEs.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetTariffsRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 GetTariffsResponse {
    #[serde(rename = "status")]
    pub status: TariffGetStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "tariffAssignments",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tariff_assignments: Option<Vec<TariffAssignment>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetTransactionStatusRequest {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetTransactionStatusRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.transaction_id {
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        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 GetTransactionStatusResponse {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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 = "getVariableData")]
    pub get_variable_data: Vec<GetVariableData>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetVariablesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 GetVariablesResponse {
    #[serde(rename = "getVariableResult")]
    pub get_variable_result: Vec<GetVariableResult>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for GetVariablesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 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 {
    /// Contains the current time of the CSMS.
    #[serde(rename = "currentTime")]
    pub current_time: DateTime,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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 = "certificateType")]
    pub certificate_type: InstallCertificateUseEnum,
    /// A PEM encoded X.509 certificate.
    #[serde(rename = "certificate")]
    pub certificate: String,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for InstallCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.certificate;
            let p = path.field("certificate");
            v::max_length(x, 10000, &p)?;
        }
        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 InstallCertificateResponse {
    #[serde(rename = "status")]
    pub status: InstallCertificateStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for InstallCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 LogStatusNotificationRequest {
    #[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>,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for LogStatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MeterValuesRequest {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for MeterValuesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &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)?;
            }
        }
        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 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 NotifyAllowedEnergyTransferRequest {
    /// The transaction for which the allowed energy transfer is allowed.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
    /// Modes of energy transfer that are accepted by CSMS.
    #[serde(rename = "allowedEnergyTransfer")]
    pub allowed_energy_transfer: Vec<EnergyTransferModeEnum>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyAllowedEnergyTransferRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        {
            let x = &self.allowed_energy_transfer;
            let p = path.field("allowedEnergyTransfer");
            v::items(x, Some(1), None, &p)?;
        }
        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 NotifyAllowedEnergyTransferResponse {
    #[serde(rename = "status")]
    pub status: NotifyAllowedEnergyTransferStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyAllowedEnergyTransferResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 = "chargingSchedule",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_schedule: Option<Vec<ChargingSchedule>>,
    /// The EVSE to which the charging limit is set. If absent or when zero, it applies to the entire Charging Station.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(rename = "chargingLimit")]
    pub charging_limit: ChargingLimit,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyChargingLimitRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
            }
        }
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.charging_limit;
            let p = path.field("chargingLimit");
            x.validate(&p)?;
        }
        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 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 {
    /// (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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyCustomerInformationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.data;
            let p = path.field("data");
            v::max_length(x, 512, &p)?;
        }
        {
            let x = &self.seq_no;
            let p = path.field("seqNo");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.request_id;
            let p = path.field("requestId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 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 NotifyDERAlarmRequest {
    #[serde(rename = "controlType")]
    pub control_type: DERControlEnum,
    #[serde(
        rename = "gridEventFault",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub grid_event_fault: Option<GridEventFaultEnum>,
    /// True when error condition has ended.
    /// Absent or false when alarm has started.
    #[serde(
        rename = "alarmEnded",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub alarm_ended: Option<bool>,
    /// Time of start or end of alarm.
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    /// Optional info provided by EV.
    #[serde(rename = "extraInfo", default, skip_serializing_if = "Option::is_none")]
    pub extra_info: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyDERAlarmRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.extra_info {
            let p = path.field("extraInfo");
            v::max_length(x, 200, &p)?;
        }
        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 NotifyDERAlarmResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyDERAlarmResponse {
    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 NotifyDERStartStopRequest {
    /// Id of the started or stopped DER control.
    /// Corresponds to the _controlId_ of the SetDERControlRequest.
    #[serde(rename = "controlId")]
    pub control_id: String,
    /// True if DER control has started. False if it has ended.
    #[serde(rename = "started")]
    pub started: bool,
    /// Time of start or end of event.
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    /// List of controlIds that are superseded as a result of this control starting.
    #[serde(
        rename = "supersededIds",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub superseded_ids: Option<Vec<String>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyDERStartStopRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.control_id;
            let p = path.field("controlId");
            v::max_length(x, 36, &p)?;
        }
        if let Some(x) = &self.superseded_ids {
            let p = path.field("supersededIds");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 36, &p0)?;
            }
        }
        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 NotifyDERStartStopResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyDERStartStopResponse {
    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 = "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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyDisplayMessagesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
            }
        }
        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 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 {
    /// Defines the EVSE and connector to which the EV is connected. EvseId may not be 0.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    /// Contains the maximum elements the EV supports for: +
    /// - ISO 15118-2: schedule tuples in SASchedule (both Pmax and Tariff). +
    /// - ISO 15118-20: PowerScheduleEntry, PriceRule and PriceLevelScheduleEntries.
    #[serde(
        rename = "maxScheduleTuples",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub max_schedule_tuples: Option<i64>,
    #[serde(rename = "chargingNeeds")]
    pub charging_needs: ChargingNeeds,
    /// *(2.1)* Time when EV charging needs were received. +
    /// Field can be added when charging station was offline when charging needs were received.
    #[serde(rename = "timestamp", default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<DateTime>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyEVChargingNeedsRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 1i64, &p)?;
        }
        if let Some(x) = &self.max_schedule_tuples {
            let p = path.field("maxScheduleTuples");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.charging_needs;
            let p = path.field("chargingNeeds");
            x.validate(&p)?;
        }
        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 NotifyEVChargingNeedsResponse {
    #[serde(rename = "status")]
    pub status: NotifyEVChargingNeedsStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyEVChargingNeedsResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 NotifyEVChargingScheduleRequest {
    /// 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,
    /// *(2.1)* Id  of the _chargingSchedule_ that EV selected from the provided ChargingProfile.
    #[serde(
        rename = "selectedChargingScheduleId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub selected_charging_schedule_id: Option<i64>,
    /// *(2.1)* True when power tolerance is accepted by EV.
    /// This value is taken from EVPowerProfile.PowerToleranceAcceptance in the ISO 15118-20 PowerDeliverReq message..
    #[serde(
        rename = "powerToleranceAcceptance",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub power_tolerance_acceptance: Option<bool>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyEVChargingScheduleRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.charging_schedule;
            let p = path.field("chargingSchedule");
            x.validate(&p)?;
        }
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 1i64, &p)?;
        }
        if let Some(x) = &self.selected_charging_schedule_id {
            let p = path.field("selectedChargingScheduleId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 NotifyEVChargingScheduleResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyEVChargingScheduleResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 NotifyEventRequest {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyEventRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.seq_no;
            let p = path.field("seqNo");
            v::minimum(*x, 0i64, &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)?;
            }
        }
        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 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 = "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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyMonitoringReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
            }
        }
        {
            let x = &self.seq_no;
            let p = path.field("seqNo");
            v::minimum(*x, 0i64, &p)?;
        }
        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 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 NotifyPeriodicEventStream {
    #[serde(rename = "data")]
    pub data: Vec<StreamDataElement>,
    /// Id of stream.
    #[serde(rename = "id")]
    pub id: i64,
    /// Number of data elements still pending to be sent.
    #[serde(rename = "pending")]
    pub pending: i64,
    /// Base timestamp to add to time offset of values.
    #[serde(rename = "basetime")]
    pub basetime: DateTime,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyPeriodicEventStream {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.data;
            let p = path.field("data");
            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.id;
            let p = path.field("id");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.pending;
            let p = path.field("pending");
            v::minimum(*x, 0i64, &p)?;
        }
        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 NotifyPriorityChargingRequest {
    /// The transaction for which priority charging is requested.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
    /// True if priority charging was activated. False if it has stopped using the priority charging profile.
    #[serde(rename = "activated")]
    pub activated: bool,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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

/// This response message has an empty body.
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NotifyPriorityChargingResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyPriorityChargingResponse {
    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 {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyReportRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
            }
        }
        {
            let x = &self.seq_no;
            let p = path.field("seqNo");
            v::minimum(*x, 0i64, &p)?;
        }
        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 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 NotifySettlementRequest {
    /// The _transactionId_ that the settlement belongs to. Can be empty if the payment transaction is canceled prior to the start of the OCPP transaction.
    #[serde(
        rename = "transactionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub transaction_id: Option<String>,
    /// The payment reference received from the payment terminal and is used as the value for _idToken_.
    #[serde(rename = "pspRef")]
    pub psp_ref: String,
    #[serde(rename = "status")]
    pub status: PaymentStatusEnum,
    /// Additional information from payment terminal/payment process.
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<String>,
    /// The amount that was settled, or attempted to be settled (in case of failure).
    #[serde(rename = "settlementAmount")]
    pub settlement_amount: f64,
    /// The time when the settlement was done.
    #[serde(rename = "settlementTime")]
    pub settlement_time: DateTime,
    #[serde(rename = "receiptId", default, skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    /// The receipt URL, to be used if the receipt is generated by the payment terminal or the CS.
    #[serde(
        rename = "receiptUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub receipt_url: Option<String>,
    #[serde(
        rename = "vatCompany",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub vat_company: Option<Address>,
    /// VAT number for a company receipt.
    #[serde(rename = "vatNumber", default, skip_serializing_if = "Option::is_none")]
    pub vat_number: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifySettlementRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.transaction_id {
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        {
            let x = &self.psp_ref;
            let p = path.field("pspRef");
            v::max_length(x, 255, &p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            v::max_length(x, 500, &p)?;
        }
        if let Some(x) = &self.receipt_id {
            let p = path.field("receiptId");
            v::max_length(x, 50, &p)?;
        }
        if let Some(x) = &self.receipt_url {
            let p = path.field("receiptUrl");
            v::max_length(x, 2000, &p)?;
        }
        if let Some(x) = &self.vat_company {
            let p = path.field("vatCompany");
            x.validate(&p)?;
        }
        if let Some(x) = &self.vat_number {
            let p = path.field("vatNumber");
            v::max_length(x, 20, &p)?;
        }
        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 NotifySettlementResponse {
    /// The receipt URL if receipt generated by CSMS. The Charging Station can QR encode it and show it to the EV Driver.
    #[serde(
        rename = "receiptUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub receipt_url: Option<String>,
    /// The receipt id if the receipt is generated by CSMS.
    #[serde(rename = "receiptId", default, skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifySettlementResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.receipt_url {
            let p = path.field("receiptUrl");
            v::max_length(x, 2000, &p)?;
        }
        if let Some(x) = &self.receipt_id {
            let p = path.field("receiptId");
            v::max_length(x, 50, &p)?;
        }
        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 NotifyWebPaymentStartedRequest {
    /// EVSE id for which transaction is requested.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    /// Timeout value in seconds after which no result of web payment process (e.g. QR code scanning) is to be expected anymore.
    #[serde(rename = "timeout")]
    pub timeout: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyWebPaymentStartedRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 NotifyWebPaymentStartedResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for NotifyWebPaymentStartedResponse {
    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 OpenPeriodicEventStreamRequest {
    #[serde(rename = "constantStreamData")]
    pub constant_stream_data: ConstantStreamData,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for OpenPeriodicEventStreamRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.constant_stream_data;
            let p = path.field("constantStreamData");
            x.validate(&p)?;
        }
        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 OpenPeriodicEventStreamResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for OpenPeriodicEventStreamResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 {
    /// 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 retry
    /// 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.
    /// If the value is 0, it means: no retries.
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for PublishFirmwareRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.location;
            let p = path.field("location");
            v::max_length(x, 2000, &p)?;
        }
        if let Some(x) = &self.retries {
            let p = path.field("retries");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.checksum;
            let p = path.field("checksum");
            v::max_length(x, 32, &p)?;
        }
        {
            let x = &self.request_id;
            let p = path.field("requestId");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.retry_interval {
            let p = path.field("retryInterval");
            v::minimum(*x, 0i64, &p)?;
        }
        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 PublishFirmwareResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for PublishFirmwareResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 PublishFirmwareStatusNotificationRequest {
    #[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>,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for PublishFirmwareStatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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, 2000, &p0)?;
            }
        }
        if let Some(x) = &self.request_id {
            let p = path.field("requestId");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 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 PullDynamicScheduleUpdateRequest {
    /// Id of charging profile to update.
    #[serde(rename = "chargingProfileId")]
    pub charging_profile_id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for PullDynamicScheduleUpdateRequest {
    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 PullDynamicScheduleUpdateResponse {
    #[serde(
        rename = "scheduleUpdate",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub schedule_update: Option<ChargingScheduleUpdate>,
    #[serde(rename = "status")]
    pub status: ChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for PullDynamicScheduleUpdateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.schedule_update {
            let p = path.field("scheduleUpdate");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 {
    /// 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,
    /// Source that has installed this charging profile. Values defined in Appendix as ChargingLimitSourceEnumStringType.
    #[serde(rename = "chargingLimitSource")]
    pub charging_limit_source: String,
    #[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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReportChargingProfilesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.charging_limit_source;
            let p = path.field("chargingLimitSource");
            v::max_length(x, 20, &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)?;
            }
        }
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 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 ReportDERControlRequest {
    #[serde(rename = "curve", default, skip_serializing_if = "Option::is_none")]
    pub curve: Option<Vec<DERCurveGet>>,
    #[serde(
        rename = "enterService",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub enter_service: Option<Vec<EnterServiceGet>>,
    #[serde(
        rename = "fixedPFAbsorb",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub fixed_pf_absorb: Option<Vec<FixedPFGet>>,
    #[serde(
        rename = "fixedPFInject",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub fixed_pf_inject: Option<Vec<FixedPFGet>>,
    #[serde(rename = "fixedVar", default, skip_serializing_if = "Option::is_none")]
    pub fixed_var: Option<Vec<FixedVarGet>>,
    #[serde(rename = "freqDroop", default, skip_serializing_if = "Option::is_none")]
    pub freq_droop: Option<Vec<FreqDroopGet>>,
    #[serde(rename = "gradient", default, skip_serializing_if = "Option::is_none")]
    pub gradient: Option<Vec<GradientGet>>,
    #[serde(
        rename = "limitMaxDischarge",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub limit_max_discharge: Option<Vec<LimitMaxDischargeGet>>,
    /// RequestId from GetDERControlRequest.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReportDERControlRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.curve {
            let p = path.field("curve");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.enter_service {
            let p = path.field("enterService");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.fixed_pf_absorb {
            let p = path.field("fixedPFAbsorb");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.fixed_pf_inject {
            let p = path.field("fixedPFInject");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.fixed_var {
            let p = path.field("fixedVar");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.freq_droop {
            let p = path.field("freqDroop");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.gradient {
            let p = path.field("gradient");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.limit_max_discharge {
            let p = path.field("limitMaxDischarge");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}

/// This message has no parameters.
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReportDERControlResponse {
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReportDERControlResponse {
    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 RequestBatterySwapRequest {
    #[serde(rename = "idToken")]
    pub id_token: IdToken,
    /// Request id to match with BatterySwapRequest.
    #[serde(rename = "requestId")]
    pub request_id: i64,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for RequestBatterySwapRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id_token;
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        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 RequestBatterySwapResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for RequestBatterySwapResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 {
    /// 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 will 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for RequestStartTransactionRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 1i64, &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)?;
        }
        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 RequestStartTransactionResponse {
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for RequestStartTransactionResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
        }
        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 RequestStopTransactionRequest {
    /// The identifier of the transaction which the Charging Station is requested to stop.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for RequestStopTransactionRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        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 RequestStopTransactionResponse {
    #[serde(rename = "status")]
    pub status: RequestStartStopStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for RequestStopTransactionResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ReservationStatusUpdateRequest {
    /// The ID of the reservation.
    #[serde(rename = "reservationId")]
    pub reservation_id: i64,
    #[serde(rename = "reservationUpdateStatus")]
    pub reservation_update_status: ReservationUpdateStatusEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReservationStatusUpdateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.reservation_id;
            let p = path.field("reservationId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 {
    /// 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,
    /// This field specifies the connector type. Values defined in Appendix as ConnectorEnumStringType.
    #[serde(
        rename = "connectorType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub connector_type: Option<String>,
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReserveNowRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id;
            let p = path.field("id");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.connector_type {
            let p = path.field("connectorType");
            v::max_length(x, 20, &p)?;
        }
        {
            let x = &self.id_token;
            let p = path.field("idToken");
            x.validate(&p)?;
        }
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.group_id_token {
            let p = path.field("groupIdToken");
            x.validate(&p)?;
        }
        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 ReserveNowResponse {
    #[serde(rename = "status")]
    pub status: ReserveNowStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ReserveNowResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 ResetRequest {
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ResetRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "status")]
    pub status: ResetStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for ResetResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SecurityEventNotificationRequest {
    /// 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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SecurityEventNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
        }
        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 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 = "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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SendLocalListRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        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)?;
            }
        }
        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 SendLocalListResponse {
    #[serde(rename = "status")]
    pub status: SendLocalListStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SendLocalListResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetChargingProfileRequest {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetChargingProfileRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.charging_profile;
            let p = path.field("chargingProfile");
            x.validate(&p)?;
        }
        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 SetChargingProfileResponse {
    #[serde(rename = "status")]
    pub status: ChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetChargingProfileResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetDERControlRequest {
    /// True if this is a default DER control
    #[serde(rename = "isDefault")]
    pub is_default: bool,
    /// Unique id of this control, e.g. UUID
    #[serde(rename = "controlId")]
    pub control_id: String,
    #[serde(rename = "controlType")]
    pub control_type: DERControlEnum,
    #[serde(rename = "curve", default, skip_serializing_if = "Option::is_none")]
    pub curve: Option<DERCurve>,
    #[serde(
        rename = "enterService",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub enter_service: Option<EnterService>,
    #[serde(
        rename = "fixedPFAbsorb",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub fixed_pf_absorb: Option<FixedPF>,
    #[serde(
        rename = "fixedPFInject",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub fixed_pf_inject: Option<FixedPF>,
    #[serde(rename = "fixedVar", default, skip_serializing_if = "Option::is_none")]
    pub fixed_var: Option<FixedVar>,
    #[serde(rename = "freqDroop", default, skip_serializing_if = "Option::is_none")]
    pub freq_droop: Option<FreqDroop>,
    #[serde(rename = "gradient", default, skip_serializing_if = "Option::is_none")]
    pub gradient: Option<Gradient>,
    #[serde(
        rename = "limitMaxDischarge",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub limit_max_discharge: Option<LimitMaxDischarge>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetDERControlRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.control_id;
            let p = path.field("controlId");
            v::max_length(x, 36, &p)?;
        }
        if let Some(x) = &self.curve {
            let p = path.field("curve");
            x.validate(&p)?;
        }
        if let Some(x) = &self.enter_service {
            let p = path.field("enterService");
            x.validate(&p)?;
        }
        if let Some(x) = &self.fixed_pf_absorb {
            let p = path.field("fixedPFAbsorb");
            x.validate(&p)?;
        }
        if let Some(x) = &self.fixed_pf_inject {
            let p = path.field("fixedPFInject");
            x.validate(&p)?;
        }
        if let Some(x) = &self.fixed_var {
            let p = path.field("fixedVar");
            x.validate(&p)?;
        }
        if let Some(x) = &self.freq_droop {
            let p = path.field("freqDroop");
            x.validate(&p)?;
        }
        if let Some(x) = &self.gradient {
            let p = path.field("gradient");
            x.validate(&p)?;
        }
        if let Some(x) = &self.limit_max_discharge {
            let p = path.field("limitMaxDischarge");
            x.validate(&p)?;
        }
        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 SetDERControlResponse {
    #[serde(rename = "status")]
    pub status: DERControlStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// List of controlIds that are superseded as a result of setting this control.
    #[serde(
        rename = "supersededIds",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub superseded_ids: Option<Vec<String>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetDERControlResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.superseded_ids {
            let p = path.field("supersededIds");
            v::items(x, Some(1), Some(24), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 36, &p0)?;
            }
        }
        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 SetDefaultTariffRequest {
    /// EVSE that tariff applies to. When _evseId_ = 0, then tarriff applies to all EVSEs.
    #[serde(rename = "evseId")]
    pub evse_id: i64,
    #[serde(rename = "tariff")]
    pub tariff: Tariff,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetDefaultTariffRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.tariff;
            let p = path.field("tariff");
            x.validate(&p)?;
        }
        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 SetDefaultTariffResponse {
    #[serde(rename = "status")]
    pub status: TariffSetStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetDefaultTariffResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetDisplayMessageRequest {
    #[serde(rename = "message")]
    pub message: MessageInfo,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetDisplayMessageRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.message;
            let p = path.field("message");
            x.validate(&p)?;
        }
        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 SetDisplayMessageResponse {
    #[serde(rename = "status")]
    pub status: DisplayMessageStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetDisplayMessageResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetMonitoringBaseRequest {
    #[serde(rename = "monitoringBase")]
    pub monitoring_base: MonitoringBaseEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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 = "status")]
    pub status: GenericDeviceModelStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetMonitoringBaseResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetMonitoringLevelRequest {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetMonitoringLevelRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.severity;
            let p = path.field("severity");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetMonitoringLevelResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetNetworkProfileRequest {
    /// Slot in which the configuration should be stored.
    #[serde(rename = "configurationSlot")]
    pub configuration_slot: i64,
    #[serde(rename = "connectionData")]
    pub connection_data: NetworkConnectionProfile,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetNetworkProfileRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.connection_data;
            let p = path.field("connectionData");
            x.validate(&p)?;
        }
        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 SetNetworkProfileResponse {
    #[serde(rename = "status")]
    pub status: SetNetworkProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetNetworkProfileResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 SetVariableMonitoringRequest {
    #[serde(rename = "setMonitoringData")]
    pub set_monitoring_data: Vec<SetMonitoringData>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetVariableMonitoringRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 SetVariableMonitoringResponse {
    #[serde(rename = "setMonitoringResult")]
    pub set_monitoring_result: Vec<SetMonitoringResult>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetVariableMonitoringResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 SetVariablesRequest {
    #[serde(rename = "setVariableData")]
    pub set_variable_data: Vec<SetVariableData>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetVariablesRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 SetVariablesResponse {
    #[serde(rename = "setVariableResult")]
    pub set_variable_result: Vec<SetVariableResult>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SetVariablesResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            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)?;
            }
        }
        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 SignCertificateRequest {
    /// 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>,
    #[serde(
        rename = "hashRootCertificate",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub hash_root_certificate: Option<CertificateHashData>,
    /// *(2.1)* RequestId to match this message with the CertificateSignedRequest.
    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<i64>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SignCertificateRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.csr;
            let p = path.field("csr");
            v::max_length(x, 5500, &p)?;
        }
        if let Some(x) = &self.hash_root_certificate {
            let p = path.field("hashRootCertificate");
            x.validate(&p)?;
        }
        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 SignCertificateResponse {
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for SignCertificateResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 StatusNotificationRequest {
    /// The time for which the status is reported.
    #[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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for StatusNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.connector_id;
            let p = path.field("connectorId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "costDetails",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub cost_details: Option<CostDetails>,
    #[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 as follows: +
    /// 1: The numberPhases in the currently used ChargingSchedule. +
    /// 2: The number of phases provided 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 = "preconditioningStatus",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub preconditioning_status: Option<PreconditioningStatusEnum>,
    /// *(2.1)* True when EVSE electronics are in sleep mode for this transaction. Default value (when absent) is false.
    #[serde(rename = "evseSleep", default, skip_serializing_if = "Option::is_none")]
    pub evse_sleep: Option<bool>,
    #[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>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for TransactionEventRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.cost_details {
            let p = path.field("costDetails");
            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.seq_no;
            let p = path.field("seqNo");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.number_of_phases_used {
            let p = path.field("numberOfPhasesUsed");
            v::minimum(*x, 0i64, &p)?;
            v::maximum(*x, 3i64, &p)?;
        }
        if let Some(x) = &self.reservation_id {
            let p = path.field("reservationId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            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)?;
        }
        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 TransactionEventResponse {
    /// When _eventType_ of TransactionEventRequest is Updated, then this value contains the running cost. When _eventType_ of TransactionEventRequest is Ended, then this contains the final total cost of this transaction, including taxes, in the currency configured with the Configuration Variable: Currency. Absence of this value does not imply that the transaction was free. To indicate a free transaction, the CSMS SHALL send a value of 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; has a higher priority than 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 = "transactionLimit",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub transaction_limit: Option<TransactionLimit>,
    #[serde(
        rename = "updatedPersonalMessage",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub updated_personal_message: Option<MessageContent>,
    #[serde(
        rename = "updatedPersonalMessageExtra",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub updated_personal_message_extra: Option<Vec<MessageContent>>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for TransactionEventResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.id_token_info {
            let p = path.field("idTokenInfo");
            x.validate(&p)?;
        }
        if let Some(x) = &self.transaction_limit {
            let p = path.field("transactionLimit");
            x.validate(&p)?;
        }
        if let Some(x) = &self.updated_personal_message {
            let p = path.field("updatedPersonalMessage");
            x.validate(&p)?;
        }
        if let Some(x) = &self.updated_personal_message_extra {
            let p = path.field("updatedPersonalMessageExtra");
            v::items(x, Some(1), Some(4), &p)?;
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        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 TriggerMessageRequest {
    #[serde(rename = "evse", default, skip_serializing_if = "Option::is_none")]
    pub evse: Option<EVSE>,
    #[serde(rename = "requestedMessage")]
    pub requested_message: MessageTriggerEnum,
    /// *(2.1)* When _requestedMessage_ = `CustomTrigger` this will trigger sending the corresponding message in field _customTrigger_, if supported by Charging Station.
    #[serde(
        rename = "customTrigger",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_trigger: Option<String>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for TriggerMessageRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.evse {
            let p = path.field("evse");
            x.validate(&p)?;
        }
        if let Some(x) = &self.custom_trigger {
            let p = path.field("customTrigger");
            v::max_length(x, 50, &p)?;
        }
        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 TriggerMessageResponse {
    #[serde(rename = "status")]
    pub status: TriggerMessageStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for TriggerMessageResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 UnlockConnectorRequest {
    /// 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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UnlockConnectorRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.evse_id;
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.connector_id;
            let p = path.field("connectorId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 = "status")]
    pub status: UnlockStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UnlockConnectorResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 UnpublishFirmwareRequest {
    /// The MD5 checksum over the entire firmware file as a hexadecimal string of length 32.
    #[serde(rename = "checksum")]
    pub checksum: String,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UnpublishFirmwareRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.checksum;
            let p = path.field("checksum");
            v::max_length(x, 32, &p)?;
        }
        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 UnpublishFirmwareResponse {
    #[serde(rename = "status")]
    pub status: UnpublishFirmwareStatusEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

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

/// Id of dynamic charging profile to update.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UpdateDynamicScheduleRequest {
    /// Id of charging profile to update.
    #[serde(rename = "chargingProfileId")]
    pub charging_profile_id: i64,
    #[serde(rename = "scheduleUpdate")]
    pub schedule_update: ChargingScheduleUpdate,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UpdateDynamicScheduleRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.schedule_update;
            let p = path.field("scheduleUpdate");
            x.validate(&p)?;
        }
        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 UpdateDynamicScheduleResponse {
    #[serde(rename = "status")]
    pub status: ChargingProfileStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UpdateDynamicScheduleResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 {
    /// This specifies how many times Charging Station must retry 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.
    /// If the value is 0, it means: no retries.
    #[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,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UpdateFirmwareRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.retries {
            let p = path.field("retries");
            v::minimum(*x, 0i64, &p)?;
        }
        {
            let x = &self.firmware;
            let p = path.field("firmware");
            x.validate(&p)?;
        }
        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 UpdateFirmwareResponse {
    #[serde(rename = "status")]
    pub status: UpdateFirmwareStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UpdateFirmwareResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 UsePriorityChargingRequest {
    /// The transaction for which priority charging is requested.
    #[serde(rename = "transactionId")]
    pub transaction_id: String,
    /// True to request priority charging.
    /// False to request stopping priority charging.
    #[serde(rename = "activate")]
    pub activate: bool,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UsePriorityChargingRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.transaction_id;
            let p = path.field("transactionId");
            v::max_length(x, 36, &p)?;
        }
        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 UsePriorityChargingResponse {
    #[serde(rename = "status")]
    pub status: PriorityChargingStatusEnum,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for UsePriorityChargingResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        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 VatNumberValidationRequest {
    /// VAT number to check.
    #[serde(rename = "vatNumber")]
    pub vat_number: String,
    /// EVSE id for which check is done
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for VatNumberValidationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.vat_number;
            let p = path.field("vatNumber");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        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 VatNumberValidationResponse {
    #[serde(rename = "company", default, skip_serializing_if = "Option::is_none")]
    pub company: Option<Address>,
    #[serde(
        rename = "statusInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_info: Option<StatusInfo>,
    /// VAT number that was requested.
    #[serde(rename = "vatNumber")]
    pub vat_number: String,
    /// EVSE id for which check was requested.
    #[serde(rename = "evseId", default, skip_serializing_if = "Option::is_none")]
    pub evse_id: Option<i64>,
    #[serde(rename = "status")]
    pub status: GenericStatusEnum,
    #[serde(
        rename = "customData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_data: Option<CustomData>,
}

impl Validate for VatNumberValidationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.company {
            let p = path.field("company");
            x.validate(&p)?;
        }
        if let Some(x) = &self.status_info {
            let p = path.field("statusInfo");
            x.validate(&p)?;
        }
        {
            let x = &self.vat_number;
            let p = path.field("vatNumber");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.evse_id {
            let p = path.field("evseId");
            v::minimum(*x, 0i64, &p)?;
        }
        if let Some(x) = &self.custom_data {
            let p = path.field("customData");
            x.validate(&p)?;
        }
        Ok(())
    }
}