codetics-ocpp16 0.1.0

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

//! OCPP 1.6 request / response payloads.

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

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AuthorizeRequest {
    #[serde(rename = "idTag")]
    pub id_tag: String,
}

impl Validate for AuthorizeRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id_tag;
            let p = path.field("idTag");
            v::max_length(x, 20, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AuthorizeResponse {
    #[serde(rename = "idTagInfo")]
    pub id_tag_info: IdTagInfo,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BootNotificationRequest {
    #[serde(rename = "chargePointVendor")]
    pub charge_point_vendor: String,
    #[serde(rename = "chargePointModel")]
    pub charge_point_model: String,
    #[serde(
        rename = "chargePointSerialNumber",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charge_point_serial_number: Option<String>,
    #[serde(
        rename = "chargeBoxSerialNumber",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charge_box_serial_number: Option<String>,
    #[serde(
        rename = "firmwareVersion",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub firmware_version: Option<String>,
    #[serde(rename = "iccid", default, skip_serializing_if = "Option::is_none")]
    pub iccid: Option<String>,
    #[serde(rename = "imsi", default, skip_serializing_if = "Option::is_none")]
    pub imsi: Option<String>,
    #[serde(rename = "meterType", default, skip_serializing_if = "Option::is_none")]
    pub meter_type: Option<String>,
    #[serde(
        rename = "meterSerialNumber",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub meter_serial_number: Option<String>,
}

impl Validate for BootNotificationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.charge_point_vendor;
            let p = path.field("chargePointVendor");
            v::max_length(x, 20, &p)?;
        }
        {
            let x = &self.charge_point_model;
            let p = path.field("chargePointModel");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.charge_point_serial_number {
            let p = path.field("chargePointSerialNumber");
            v::max_length(x, 25, &p)?;
        }
        if let Some(x) = &self.charge_box_serial_number {
            let p = path.field("chargeBoxSerialNumber");
            v::max_length(x, 25, &p)?;
        }
        if let Some(x) = &self.firmware_version {
            let p = path.field("firmwareVersion");
            v::max_length(x, 50, &p)?;
        }
        if let Some(x) = &self.iccid {
            let p = path.field("iccid");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.imsi {
            let p = path.field("imsi");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.meter_type {
            let p = path.field("meterType");
            v::max_length(x, 25, &p)?;
        }
        if let Some(x) = &self.meter_serial_number {
            let p = path.field("meterSerialNumber");
            v::max_length(x, 25, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BootNotificationResponse {
    #[serde(rename = "status")]
    pub status: RegistrationStatus,
    #[serde(rename = "currentTime")]
    pub current_time: DateTime,
    #[serde(rename = "interval")]
    pub interval: i64,
}

impl Validate for BootNotificationResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CancelReservationRequest {
    #[serde(rename = "reservationId")]
    pub reservation_id: i64,
}

impl Validate for CancelReservationRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CancelReservationResponse {
    #[serde(rename = "status")]
    pub status: CancelReservationStatus,
}

impl Validate for CancelReservationResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChangeAvailabilityRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(rename = "type")]
    pub r#type: AvailabilityType,
}

impl Validate for ChangeAvailabilityRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChangeAvailabilityResponse {
    #[serde(rename = "status")]
    pub status: AvailabilityStatus,
}

impl Validate for ChangeAvailabilityResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChangeConfigurationRequest {
    #[serde(rename = "key")]
    pub key: String,
    #[serde(rename = "value")]
    pub value: String,
}

impl Validate for ChangeConfigurationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.key;
            let p = path.field("key");
            v::max_length(x, 50, &p)?;
        }
        {
            let x = &self.value;
            let p = path.field("value");
            v::max_length(x, 500, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChangeConfigurationResponse {
    #[serde(rename = "status")]
    pub status: ConfigurationStatus,
}

impl Validate for ChangeConfigurationResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearCacheRequest {}

impl Validate for ClearCacheRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearCacheResponse {
    #[serde(rename = "status")]
    pub status: ClearCacheStatus,
}

impl Validate for ClearCacheResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearChargingProfileRequest {
    #[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(
        rename = "connectorId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub connector_id: Option<i64>,
    #[serde(
        rename = "chargingProfilePurpose",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_profile_purpose: Option<ChargingProfilePurposeType>,
    #[serde(
        rename = "stackLevel",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub stack_level: Option<i64>,
}

impl Validate for ClearChargingProfileRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClearChargingProfileResponse {
    #[serde(rename = "status")]
    pub status: ClearChargingProfileStatus,
}

impl Validate for ClearChargingProfileResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DataTransferRequest {
    #[serde(rename = "vendorId")]
    pub vendor_id: String,
    #[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
    pub message_id: Option<String>,
    #[serde(rename = "data", default, skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DataTransferResponse {
    #[serde(rename = "status")]
    pub status: DataTransferStatus,
    #[serde(rename = "data", default, skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
}

impl Validate for DataTransferResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DiagnosticsStatusNotificationRequest {
    #[serde(rename = "status")]
    pub status: DiagnosticsStatus,
}

impl Validate for DiagnosticsStatusNotificationRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DiagnosticsStatusNotificationResponse {}

impl Validate for DiagnosticsStatusNotificationResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FirmwareStatusNotificationRequest {
    #[serde(rename = "status")]
    pub status: FirmwareStatus,
}

impl Validate for FirmwareStatusNotificationRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FirmwareStatusNotificationResponse {}

impl Validate for FirmwareStatusNotificationResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetCompositeScheduleRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(rename = "duration")]
    pub duration: i64,
    #[serde(
        rename = "chargingRateUnit",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_rate_unit: Option<ChargingRateUnitType>,
}

impl Validate for GetCompositeScheduleRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetCompositeScheduleResponse {
    #[serde(rename = "status")]
    pub status: GetCompositeScheduleStatus,
    #[serde(
        rename = "connectorId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub connector_id: Option<i64>,
    #[serde(
        rename = "scheduleStart",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub schedule_start: Option<DateTime>,
    #[serde(
        rename = "chargingSchedule",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_schedule: Option<ChargingSchedule>,
}

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

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetConfigurationRequest {
    #[serde(rename = "key", default, skip_serializing_if = "Option::is_none")]
    pub key: Option<Vec<String>>,
}

impl Validate for GetConfigurationRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.key {
            let p = path.field("key");
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 50, &p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetConfigurationResponse {
    #[serde(
        rename = "configurationKey",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub configuration_key: Option<Vec<KeyValue>>,
    #[serde(
        rename = "unknownKey",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub unknown_key: Option<Vec<String>>,
}

impl Validate for GetConfigurationResponse {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        if let Some(x) = &self.configuration_key {
            let p = path.field("configurationKey");
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                it0.validate(&p0)?;
            }
        }
        if let Some(x) = &self.unknown_key {
            let p = path.field("unknownKey");
            for (i0, it0) in x.iter().enumerate() {
                let p0 = p.index(i0);
                v::max_length(it0, 50, &p0)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetDiagnosticsRequest {
    #[serde(rename = "location")]
    pub location: String,
    #[serde(rename = "retries", default, skip_serializing_if = "Option::is_none")]
    pub retries: Option<i64>,
    #[serde(
        rename = "retryInterval",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_interval: Option<i64>,
    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
    pub start_time: Option<DateTime>,
    #[serde(rename = "stopTime", default, skip_serializing_if = "Option::is_none")]
    pub stop_time: Option<DateTime>,
}

impl Validate for GetDiagnosticsRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetDiagnosticsResponse {
    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
    pub file_name: Option<String>,
}

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

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetLocalListVersionRequest {}

impl Validate for GetLocalListVersionRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GetLocalListVersionResponse {
    #[serde(rename = "listVersion")]
    pub list_version: i64,
}

impl Validate for GetLocalListVersionResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HeartbeatRequest {}

impl Validate for HeartbeatRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HeartbeatResponse {
    #[serde(rename = "currentTime")]
    pub current_time: DateTime,
}

impl Validate for HeartbeatResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MeterValuesRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(
        rename = "transactionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub transaction_id: Option<i64>,
    #[serde(rename = "meterValue")]
    pub meter_value: Vec<MeterValue>,
}

impl Validate for MeterValuesRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MeterValuesResponse {}

impl Validate for MeterValuesResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RemoteStartTransactionRequest {
    #[serde(
        rename = "connectorId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub connector_id: Option<i64>,
    #[serde(rename = "idTag")]
    pub id_tag: String,
    #[serde(
        rename = "chargingProfile",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub charging_profile: Option<ChargingProfile>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RemoteStartTransactionResponse {
    #[serde(rename = "status")]
    pub status: RemoteStartStopStatus,
}

impl Validate for RemoteStartTransactionResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RemoteStopTransactionRequest {
    #[serde(rename = "transactionId")]
    pub transaction_id: i64,
}

impl Validate for RemoteStopTransactionRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RemoteStopTransactionResponse {
    #[serde(rename = "status")]
    pub status: RemoteStartStopStatus,
}

impl Validate for RemoteStopTransactionResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReserveNowRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(rename = "expiryDate")]
    pub expiry_date: DateTime,
    #[serde(rename = "idTag")]
    pub id_tag: String,
    #[serde(
        rename = "parentIdTag",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub parent_id_tag: Option<String>,
    #[serde(rename = "reservationId")]
    pub reservation_id: i64,
}

impl Validate for ReserveNowRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id_tag;
            let p = path.field("idTag");
            v::max_length(x, 20, &p)?;
        }
        if let Some(x) = &self.parent_id_tag {
            let p = path.field("parentIdTag");
            v::max_length(x, 20, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReserveNowResponse {
    #[serde(rename = "status")]
    pub status: ReservationStatus,
}

impl Validate for ReserveNowResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ResetRequest {
    #[serde(rename = "type")]
    pub r#type: ResetType,
}

impl Validate for ResetRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ResetResponse {
    #[serde(rename = "status")]
    pub status: ResetStatus,
}

impl Validate for ResetResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SendLocalListRequest {
    #[serde(rename = "listVersion")]
    pub list_version: i64,
    #[serde(
        rename = "localAuthorizationList",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub local_authorization_list: Option<Vec<AuthorizationData>>,
    #[serde(rename = "updateType")]
    pub update_type: UpdateType,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SendLocalListResponse {
    #[serde(rename = "status")]
    pub status: UpdateStatus,
}

impl Validate for SendLocalListResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetChargingProfileRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(rename = "csChargingProfiles")]
    pub cs_charging_profiles: ChargingProfile,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SetChargingProfileResponse {
    #[serde(rename = "status")]
    pub status: ChargingProfileStatus,
}

impl Validate for SetChargingProfileResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StartTransactionRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(rename = "idTag")]
    pub id_tag: String,
    #[serde(rename = "meterStart")]
    pub meter_start: i64,
    #[serde(
        rename = "reservationId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub reservation_id: Option<i64>,
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
}

impl Validate for StartTransactionRequest {
    fn validate(&self, path: &Path<'_>) -> Result<(), Violation> {
        {
            let x = &self.id_tag;
            let p = path.field("idTag");
            v::max_length(x, 20, &p)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StartTransactionResponse {
    #[serde(rename = "idTagInfo")]
    pub id_tag_info: IdTagInfo,
    #[serde(rename = "transactionId")]
    pub transaction_id: i64,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StatusNotificationRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
    #[serde(rename = "errorCode")]
    pub error_code: ChargePointErrorCode,
    #[serde(rename = "info", default, skip_serializing_if = "Option::is_none")]
    pub info: Option<String>,
    #[serde(rename = "status")]
    pub status: ChargePointStatus,
    #[serde(rename = "timestamp", default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<DateTime>,
    #[serde(rename = "vendorId", default, skip_serializing_if = "Option::is_none")]
    pub vendor_id: Option<String>,
    #[serde(
        rename = "vendorErrorCode",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub vendor_error_code: Option<String>,
}

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

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StatusNotificationResponse {}

impl Validate for StatusNotificationResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StopTransactionRequest {
    #[serde(rename = "idTag", default, skip_serializing_if = "Option::is_none")]
    pub id_tag: Option<String>,
    #[serde(rename = "meterStop")]
    pub meter_stop: i64,
    #[serde(rename = "timestamp")]
    pub timestamp: DateTime,
    #[serde(rename = "transactionId")]
    pub transaction_id: i64,
    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<Reason>,
    #[serde(
        rename = "transactionData",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub transaction_data: Option<Vec<MeterValue>>,
}

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

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StopTransactionResponse {
    #[serde(rename = "idTagInfo", default, skip_serializing_if = "Option::is_none")]
    pub id_tag_info: Option<IdTagInfo>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TriggerMessageRequest {
    #[serde(rename = "requestedMessage")]
    pub requested_message: MessageTrigger,
    #[serde(
        rename = "connectorId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub connector_id: Option<i64>,
}

impl Validate for TriggerMessageRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TriggerMessageResponse {
    #[serde(rename = "status")]
    pub status: TriggerMessageStatus,
}

impl Validate for TriggerMessageResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnlockConnectorRequest {
    #[serde(rename = "connectorId")]
    pub connector_id: i64,
}

impl Validate for UnlockConnectorRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnlockConnectorResponse {
    #[serde(rename = "status")]
    pub status: UnlockStatus,
}

impl Validate for UnlockConnectorResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UpdateFirmwareRequest {
    #[serde(rename = "location")]
    pub location: String,
    #[serde(rename = "retries", default, skip_serializing_if = "Option::is_none")]
    pub retries: Option<i64>,
    #[serde(rename = "retrieveDate")]
    pub retrieve_date: DateTime,
    #[serde(
        rename = "retryInterval",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_interval: Option<i64>,
}

impl Validate for UpdateFirmwareRequest {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UpdateFirmwareResponse {}

impl Validate for UpdateFirmwareResponse {
    fn validate(&self, _path: &Path<'_>) -> Result<(), Violation> {
        Ok(())
    }
}