#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum IdTagInfoStatus {
Accepted,
Blocked,
Expired,
Invalid,
ConcurrentTx,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for IdTagInfoStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IdTagInfo {
#[cfg_attr(feature = "serde", serde(rename = "expiryDate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub expiry_date: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "parentIdTag"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub parent_id_tag: Option<heapless::String<20usize>>,
pub status: IdTagInfoStatus,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for IdTagInfo {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.status)
.map_err(|error| error.in_field("status"))?;
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BootNotificationResponseStatus {
Accepted,
Pending,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for BootNotificationResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CancelReservationResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CancelReservationResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CertificateSignedResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CertificateSignedResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChangeAvailabilityRequestType {
Inoperative,
Operative,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChangeAvailabilityRequestType {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChangeAvailabilityResponseStatus {
Accepted,
Rejected,
Scheduled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChangeAvailabilityResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChangeConfigurationResponseStatus {
Accepted,
Rejected,
RebootRequired,
NotSupported,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChangeConfigurationResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ClearCacheResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ClearCacheResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingProfilePurpose {
ChargePointMaxProfile,
TxDefaultProfile,
TxProfile,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingProfilePurpose {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ClearChargingProfileResponseStatus {
Accepted,
Unknown,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ClearChargingProfileResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DataTransferResponseStatus {
Accepted,
Rejected,
UnknownMessageId,
UnknownVendorId,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DataTransferResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum HashAlgorithm {
SHA256,
SHA384,
SHA512,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for HashAlgorithm {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CertificateHashData {
#[cfg_attr(feature = "serde", serde(rename = "hashAlgorithm"))]
pub hash_algorithm: HashAlgorithm,
#[cfg_attr(feature = "serde", serde(rename = "issuerKeyHash"))]
pub issuer_key_hash: heapless::String<128usize>,
#[cfg_attr(feature = "serde", serde(rename = "issuerNameHash"))]
pub issuer_name_hash: heapless::String<128usize>,
#[cfg_attr(feature = "serde", serde(rename = "serialNumber"))]
pub serial_number: heapless::String<40usize>,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CertificateHashData {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.hash_algorithm)
.map_err(|error| error.in_field("hashAlgorithm"))?;
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DeleteCertificateResponseStatus {
Accepted,
Failed,
NotFound,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DeleteCertificateResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DiagnosticsStatusNotificationRequestStatus {
Idle,
Uploaded,
UploadFailed,
Uploading,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for DiagnosticsStatusNotificationRequestStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ExtendedTriggerMessageRequestRequestedMessage {
BootNotification,
LogStatusNotification,
FirmwareStatusNotification,
Heartbeat,
MeterValues,
SignChargePointCertificate,
StatusNotification,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ExtendedTriggerMessageRequestRequestedMessage {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ExtendedTriggerMessageResponseStatus {
Accepted,
Rejected,
NotImplemented,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ExtendedTriggerMessageResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum FirmwareStatusNotificationRequestStatus {
Downloaded,
DownloadFailed,
Downloading,
Idle,
InstallationFailed,
Installing,
Installed,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for FirmwareStatusNotificationRequestStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingRateUnit {
A,
W,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingRateUnit {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedulePeriodItem {
pub limit: f64,
#[cfg_attr(feature = "serde", serde(rename = "numberPhases"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub number_phases: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "startPeriod"))]
pub start_period: i64,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingSchedulePeriodItem {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_multiple_of(self.limit, 0.1f64)
.map_err(|error| error.in_field("limit"))?;
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedule {
#[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
pub charging_rate_unit: ChargingRateUnit,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
pub charging_schedule_period: alloc::vec::Vec<ChargingSchedulePeriodItem>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub duration: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub min_charging_rate: Option<f64>,
#[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub start_schedule: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for ChargingSchedule {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_rate_unit)
.map_err(|error| error.in_field("chargingRateUnit"))?;
for (index, item) in self.charging_schedule_period.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingSchedulePeriod")
})?;
}
if let Some(value) = self.min_charging_rate {
crate::validate::check_multiple_of(value, 0.1f64)
.map_err(|error| error.in_field("minChargingRate"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingSchedule<
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
pub charging_rate_unit: ChargingRateUnit,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
pub charging_schedule_period: heapless::Vec<
ChargingSchedulePeriodItem,
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub duration: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub min_charging_rate: Option<f64>,
#[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub start_schedule: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize,
> crate::validate::Validate
for ChargingSchedule<CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_rate_unit)
.map_err(|error| error.in_field("chargingRateUnit"))?;
for (index, item) in self.charging_schedule_period.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| {
error.in_index(index).in_field("chargingSchedulePeriod")
})?;
}
if let Some(value) = self.min_charging_rate {
crate::validate::check_multiple_of(value, 0.1f64)
.map_err(|error| error.in_field("minChargingRate"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetCompositeScheduleResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetCompositeScheduleResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ConfigurationKeyItem {
pub key: heapless::String<50usize>,
pub readonly: bool,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub value: Option<heapless::String<500usize>>,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ConfigurationKeyItem {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CertificateType {
CentralSystemRootCertificate,
ManufacturerRootCertificate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for CertificateType {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetInstalledCertificateIdsResponseStatus {
Accepted,
NotFound,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetInstalledCertificateIdsResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Log {
#[cfg_attr(feature = "serde", serde(rename = "latestTimestamp"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub latest_timestamp: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "oldestTimestamp"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub oldest_timestamp: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "remoteLocation"))]
pub remote_location: heapless::String<512usize>,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Log {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum LogType {
DiagnosticsLog,
SecurityLog,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for LogType {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GetLogResponseStatus {
Accepted,
Rejected,
AcceptedCanceled,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for GetLogResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum InstallCertificateResponseStatus {
Accepted,
Failed,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for InstallCertificateResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum LogStatusNotificationRequestStatus {
BadMessage,
Idle,
NotSupportedOperation,
PermissionDenied,
Uploaded,
UploadFailure,
Uploading,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for LogStatusNotificationRequestStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Context {
#[cfg_attr(feature = "serde", serde(rename = "Interruption.Begin"))]
InterruptionBegin,
#[cfg_attr(feature = "serde", serde(rename = "Interruption.End"))]
InterruptionEnd,
#[cfg_attr(feature = "serde", serde(rename = "Sample.Clock"))]
SampleClock,
#[cfg_attr(feature = "serde", serde(rename = "Sample.Periodic"))]
SamplePeriodic,
#[cfg_attr(feature = "serde", serde(rename = "Transaction.Begin"))]
TransactionBegin,
#[cfg_attr(feature = "serde", serde(rename = "Transaction.End"))]
TransactionEnd,
Trigger,
Other,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Context {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Format {
Raw,
SignedData,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Format {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Location {
Cable,
EV,
Inlet,
Outlet,
Body,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Location {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Measurand {
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Register"))]
EnergyActiveExportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Register"))]
EnergyActiveImportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Register"))]
EnergyReactiveExportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Register"))]
EnergyReactiveImportRegister,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Interval"))]
EnergyActiveExportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Interval"))]
EnergyActiveImportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Interval"))]
EnergyReactiveExportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Interval"))]
EnergyReactiveImportInterval,
#[cfg_attr(feature = "serde", serde(rename = "Power.Active.Export"))]
PowerActiveExport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Active.Import"))]
PowerActiveImport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Offered"))]
PowerOffered,
#[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Export"))]
PowerReactiveExport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Import"))]
PowerReactiveImport,
#[cfg_attr(feature = "serde", serde(rename = "Power.Factor"))]
PowerFactor,
#[cfg_attr(feature = "serde", serde(rename = "Current.Import"))]
CurrentImport,
#[cfg_attr(feature = "serde", serde(rename = "Current.Export"))]
CurrentExport,
#[cfg_attr(feature = "serde", serde(rename = "Current.Offered"))]
CurrentOffered,
Voltage,
Frequency,
Temperature,
SoC,
RPM,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Measurand {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Phase {
L1,
L2,
L3,
N,
#[cfg_attr(feature = "serde", serde(rename = "L1-N"))]
L1N,
#[cfg_attr(feature = "serde", serde(rename = "L2-N"))]
L2N,
#[cfg_attr(feature = "serde", serde(rename = "L3-N"))]
L3N,
#[cfg_attr(feature = "serde", serde(rename = "L1-L2"))]
L1L2,
#[cfg_attr(feature = "serde", serde(rename = "L2-L3"))]
L2L3,
#[cfg_attr(feature = "serde", serde(rename = "L3-L1"))]
L3L1,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Phase {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SampledValueItemUnit {
Wh,
#[cfg_attr(feature = "serde", serde(rename = "kWh"))]
KWh,
#[cfg_attr(feature = "serde", serde(rename = "varh"))]
Varh,
#[cfg_attr(feature = "serde", serde(rename = "kvarh"))]
Kvarh,
W,
#[cfg_attr(feature = "serde", serde(rename = "kW"))]
KW,
VA,
#[cfg_attr(feature = "serde", serde(rename = "kVA"))]
KVA,
#[cfg_attr(feature = "serde", serde(rename = "var"))]
Var,
#[cfg_attr(feature = "serde", serde(rename = "kvar"))]
Kvar,
A,
V,
K,
Celcius,
Celsius,
Fahrenheit,
Percent,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SampledValueItemUnit {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SampledValueItem {
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub context: Option<Context>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub format: Option<Format>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub location: Option<Location>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub measurand: Option<Measurand>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub phase: Option<Phase>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit: Option<SampledValueItemUnit>,
pub value: alloc::string::String,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for SampledValueItem {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.context {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("context"))?;
}
if let Some(value) = &self.format {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("format"))?;
}
if let Some(value) = &self.location {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("location"))?;
}
if let Some(value) = &self.measurand {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("measurand"))?;
}
if let Some(value) = &self.phase {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("phase"))?;
}
if let Some(value) = &self.unit {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("unit"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SampledValueItem<const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize> {
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub context: Option<Context>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub format: Option<Format>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub location: Option<Location>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub measurand: Option<Measurand>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub phase: Option<Phase>,
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub unit: Option<SampledValueItemUnit>,
pub value: heapless::String<SAMPLED_VALUE_ITEM_VALUE_CAP>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<const SAMPLED_VALUE_ITEM_VALUE_CAP: usize> crate::validate::Validate
for SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.context {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("context"))?;
}
if let Some(value) = &self.format {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("format"))?;
}
if let Some(value) = &self.location {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("location"))?;
}
if let Some(value) = &self.measurand {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("measurand"))?;
}
if let Some(value) = &self.phase {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("phase"))?;
}
if let Some(value) = &self.unit {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("unit"))?;
}
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeterValueItem {
#[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
pub sampled_value: alloc::vec::Vec<SampledValueItem>,
pub timestamp: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for MeterValueItem {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
for (index, item) in self.sampled_value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("sampledValue"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MeterValueItem<
const METER_VALUE_ITEM_SAMPLED_VALUE_CAP: usize = 8usize,
const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
pub sampled_value: heapless::Vec<
SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
METER_VALUE_ITEM_SAMPLED_VALUE_CAP,
>,
pub timestamp: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
const METER_VALUE_ITEM_SAMPLED_VALUE_CAP: usize,
const SAMPLED_VALUE_ITEM_VALUE_CAP: usize,
> crate::validate::Validate
for MeterValueItem<METER_VALUE_ITEM_SAMPLED_VALUE_CAP, SAMPLED_VALUE_ITEM_VALUE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
for (index, item) in self.sampled_value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("sampledValue"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ChargingProfileKind {
Absolute,
Recurring,
Relative,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ChargingProfileKind {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum RecurrencyKind {
Daily,
Weekly,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for RecurrencyKind {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfile {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
pub charging_profile_id: i64,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
pub charging_profile_kind: ChargingProfileKind,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
pub charging_profile_purpose: ChargingProfilePurpose,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
pub charging_schedule: ChargingSchedule,
#[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub recurrency_kind: Option<RecurrencyKind>,
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
pub stack_level: i64,
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_from: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "validTo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_to: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for ChargingProfile {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_profile_kind)
.map_err(|error| error.in_field("chargingProfileKind"))?;
crate::validate::Validate::validate(&self.charging_profile_purpose)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
crate::validate::Validate::validate(&self.charging_schedule)
.map_err(|error| error.in_field("chargingSchedule"))?;
if let Some(value) = &self.recurrency_kind {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("recurrencyKind"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ChargingProfile<
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
pub charging_profile_id: i64,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
pub charging_profile_kind: ChargingProfileKind,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
pub charging_profile_purpose: ChargingProfilePurpose,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
pub charging_schedule: ChargingSchedule<
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
>,
#[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub recurrency_kind: Option<RecurrencyKind>,
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
pub stack_level: i64,
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_from: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "validTo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_to: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize,
> crate::validate::Validate
for ChargingProfile<CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_profile_kind)
.map_err(|error| error.in_field("chargingProfileKind"))?;
crate::validate::Validate::validate(&self.charging_profile_purpose)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
crate::validate::Validate::validate(&self.charging_schedule)
.map_err(|error| error.in_field("chargingSchedule"))?;
if let Some(value) = &self.recurrency_kind {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("recurrencyKind"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum RemoteStartTransactionResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for RemoteStartTransactionResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum RemoteStopTransactionResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for RemoteStopTransactionResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ReserveNowResponseStatus {
Accepted,
Faulted,
Occupied,
Rejected,
Unavailable,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ReserveNowResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ResetRequestType {
Hard,
Soft,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ResetRequestType {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ResetResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ResetResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LocalAuthorizationListItem {
#[cfg_attr(feature = "serde", serde(rename = "idTag"))]
pub id_tag: super::IdTag,
#[cfg_attr(feature = "serde", serde(rename = "idTagInfo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub id_tag_info: Option<IdTagInfo>,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for LocalAuthorizationListItem {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
if let Some(value) = &self.id_tag_info {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("idTagInfo"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UpdateType {
Differential,
Full,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UpdateType {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SendLocalListResponseStatus {
Accepted,
Failed,
NotSupported,
VersionMismatch,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SendLocalListResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CsChargingProfiles {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
pub charging_profile_id: i64,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
pub charging_profile_kind: ChargingProfileKind,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
pub charging_profile_purpose: ChargingProfilePurpose,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
pub charging_schedule: ChargingSchedule,
#[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub recurrency_kind: Option<RecurrencyKind>,
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
pub stack_level: i64,
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_from: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "validTo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_to: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for CsChargingProfiles {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_profile_kind)
.map_err(|error| error.in_field("chargingProfileKind"))?;
crate::validate::Validate::validate(&self.charging_profile_purpose)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
crate::validate::Validate::validate(&self.charging_schedule)
.map_err(|error| error.in_field("chargingSchedule"))?;
if let Some(value) = &self.recurrency_kind {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("recurrencyKind"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct CsChargingProfiles<
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 8usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
pub charging_profile_id: i64,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
pub charging_profile_kind: ChargingProfileKind,
#[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
pub charging_profile_purpose: ChargingProfilePurpose,
#[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
pub charging_schedule: ChargingSchedule<
CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
>,
#[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub recurrency_kind: Option<RecurrencyKind>,
#[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
pub stack_level: i64,
#[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub transaction_id: Option<i64>,
#[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_from: Option<crate::OcppTimestamp>,
#[cfg_attr(feature = "serde", serde(rename = "validTo"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub valid_to: Option<crate::OcppTimestamp>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize,
> crate::validate::Validate
for CsChargingProfiles<CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::Validate::validate(&self.charging_profile_kind)
.map_err(|error| error.in_field("chargingProfileKind"))?;
crate::validate::Validate::validate(&self.charging_profile_purpose)
.map_err(|error| error.in_field("chargingProfilePurpose"))?;
crate::validate::Validate::validate(&self.charging_schedule)
.map_err(|error| error.in_field("chargingSchedule"))?;
if let Some(value) = &self.recurrency_kind {
crate::validate::Validate::validate(value)
.map_err(|error| error.in_field("recurrencyKind"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SetChargingProfileResponseStatus {
Accepted,
Rejected,
NotSupported,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SetChargingProfileResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SignCertificateResponseStatus {
Accepted,
Rejected,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SignCertificateResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SignedFirmwareStatusNotificationRequestStatus {
Downloaded,
DownloadFailed,
Downloading,
DownloadScheduled,
DownloadPaused,
Idle,
InstallationFailed,
Installing,
Installed,
InstallRebooting,
InstallScheduled,
InstallVerificationFailed,
InvalidSignature,
SignatureVerified,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SignedFirmwareStatusNotificationRequestStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Firmware {
#[cfg_attr(feature = "serde", serde(rename = "installDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub install_date_time: Option<crate::OcppTimestamp>,
pub location: heapless::String<512usize>,
#[cfg_attr(feature = "serde", serde(rename = "retrieveDateTime"))]
pub retrieve_date_time: crate::OcppTimestamp,
pub signature: alloc::string::String,
#[cfg_attr(feature = "serde", serde(rename = "signingCertificate"))]
pub signing_certificate: alloc::string::String,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for Firmware {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_max_length(&self.signature, 800usize)
.map_err(|error| error.in_field("signature"))?;
crate::validate::check_max_length(&self.signing_certificate, 5500usize)
.map_err(|error| error.in_field("signingCertificate"))?;
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Firmware<
const FIRMWARE_SIGNATURE_CAP: usize = 800usize,
const FIRMWARE_SIGNING_CERTIFICATE_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "installDateTime"))]
#[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
pub install_date_time: Option<crate::OcppTimestamp>,
pub location: heapless::String<512usize>,
#[cfg_attr(feature = "serde", serde(rename = "retrieveDateTime"))]
pub retrieve_date_time: crate::OcppTimestamp,
pub signature: heapless::String<FIRMWARE_SIGNATURE_CAP>,
#[cfg_attr(feature = "serde", serde(rename = "signingCertificate"))]
pub signing_certificate: heapless::String<FIRMWARE_SIGNING_CERTIFICATE_CAP>,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
const FIRMWARE_SIGNATURE_CAP: usize,
const FIRMWARE_SIGNING_CERTIFICATE_CAP: usize,
> crate::validate::Validate
for Firmware<FIRMWARE_SIGNATURE_CAP, FIRMWARE_SIGNING_CERTIFICATE_CAP> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
crate::validate::check_max_length(&self.signature, 800usize)
.map_err(|error| error.in_field("signature"))?;
crate::validate::check_max_length(&self.signing_certificate, 5500usize)
.map_err(|error| error.in_field("signingCertificate"))?;
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SignedUpdateFirmwareResponseStatus {
Accepted,
Rejected,
AcceptedCanceled,
InvalidCertificate,
RevokedCertificate,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for SignedUpdateFirmwareResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ErrorCode {
ConnectorLockFailure,
EVCommunicationError,
GroundFailure,
HighTemperature,
InternalError,
LocalListConflict,
NoError,
OtherError,
OverCurrentFailure,
PowerMeterFailure,
PowerSwitchFailure,
ReaderFailure,
ResetFailure,
UnderVoltage,
OverVoltage,
WeakSignal,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for ErrorCode {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum StatusNotificationRequestStatus {
Available,
Preparing,
Charging,
SuspendedEVSE,
SuspendedEV,
Finishing,
Reserved,
Unavailable,
Faulted,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for StatusNotificationRequestStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Reason {
EmergencyStop,
EVDisconnected,
HardReset,
Local,
Other,
PowerLoss,
Reboot,
Remote,
SoftReset,
UnlockCommand,
DeAuthorized,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for Reason {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TransactionDataItem {
#[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
pub sampled_value: alloc::vec::Vec<SampledValueItem>,
pub timestamp: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", feature = "alloc"))]
impl crate::validate::Validate for TransactionDataItem {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
for (index, item) in self.sampled_value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("sampledValue"))?;
}
Ok(())
}
}
#[cfg(not(feature = "alloc"))]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TransactionDataItem<
const TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP: usize = 8usize,
const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
> {
#[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
pub sampled_value: heapless::Vec<
SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP,
>,
pub timestamp: crate::OcppTimestamp,
}
#[cfg(all(feature = "validate", not(feature = "alloc")))]
impl<
const TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP: usize,
const SAMPLED_VALUE_ITEM_VALUE_CAP: usize,
> crate::validate::Validate
for TransactionDataItem<
TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP,
SAMPLED_VALUE_ITEM_VALUE_CAP,
> {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
for (index, item) in self.sampled_value.iter().enumerate() {
crate::validate::Validate::validate(item)
.map_err(|error| error.in_index(index).in_field("sampledValue"))?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TriggerMessageRequestRequestedMessage {
BootNotification,
DiagnosticsStatusNotification,
FirmwareStatusNotification,
Heartbeat,
MeterValues,
StatusNotification,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for TriggerMessageRequestRequestedMessage {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TriggerMessageResponseStatus {
Accepted,
Rejected,
NotImplemented,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for TriggerMessageResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UnlockConnectorResponseStatus {
Unlocked,
UnlockFailed,
NotSupported,
}
#[cfg(feature = "validate")]
impl crate::validate::Validate for UnlockConnectorResponseStatus {
fn validate(&self) -> Result<(), crate::validate::ValidationError> {
Ok(())
}
}