1#[derive(Debug, Clone, PartialEq, Eq)]
5#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6pub enum IdTagInfoStatus {
7 Accepted,
8 Blocked,
9 Expired,
10 Invalid,
11 ConcurrentTx,
12}
13#[cfg(feature = "alloc")]
14#[derive(Debug, Clone, PartialEq, Eq)]
15#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16pub struct IdTagInfo {
17 #[cfg_attr(feature = "serde", serde(rename = "expiryDate"))]
18 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
19 pub expiry_date: Option<alloc::string::String>,
20 #[cfg_attr(feature = "serde", serde(rename = "parentIdTag"))]
21 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
22 pub parent_id_tag: Option<heapless::String<20usize>>,
23 pub status: IdTagInfoStatus,
24}
25#[cfg(not(feature = "alloc"))]
26#[derive(Debug, Clone, PartialEq, Eq)]
27#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28pub struct IdTagInfo<const ID_TAG_INFO_EXPIRY_DATE_CAP: usize = 1024usize> {
29 #[cfg_attr(feature = "serde", serde(rename = "expiryDate"))]
30 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
31 pub expiry_date: Option<heapless::String<ID_TAG_INFO_EXPIRY_DATE_CAP>>,
32 #[cfg_attr(feature = "serde", serde(rename = "parentIdTag"))]
33 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
34 pub parent_id_tag: Option<heapless::String<20usize>>,
35 pub status: IdTagInfoStatus,
36}
37#[derive(Debug, Clone, PartialEq, Eq)]
38#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
39pub enum BootNotificationResponseStatus {
40 Accepted,
41 Pending,
42 Rejected,
43}
44#[derive(Debug, Clone, PartialEq, Eq)]
45#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
46pub enum CancelReservationResponseStatus {
47 Accepted,
48 Rejected,
49}
50#[derive(Debug, Clone, PartialEq, Eq)]
51#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
52pub enum ChangeAvailabilityRequestType {
53 Inoperative,
54 Operative,
55}
56#[derive(Debug, Clone, PartialEq, Eq)]
57#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
58pub enum ChangeAvailabilityResponseStatus {
59 Accepted,
60 Rejected,
61 Scheduled,
62}
63#[derive(Debug, Clone, PartialEq, Eq)]
64#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
65pub enum ChangeConfigurationResponseStatus {
66 Accepted,
67 Rejected,
68 RebootRequired,
69 NotSupported,
70}
71#[derive(Debug, Clone, PartialEq, Eq)]
72#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
73pub enum ClearCacheResponseStatus {
74 Accepted,
75 Rejected,
76}
77#[derive(Debug, Clone, PartialEq, Eq)]
78#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
79pub enum ChargingProfilePurpose {
80 ChargePointMaxProfile,
81 TxDefaultProfile,
82 TxProfile,
83}
84#[derive(Debug, Clone, PartialEq, Eq)]
85#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
86pub enum ClearChargingProfileResponseStatus {
87 Accepted,
88 Unknown,
89}
90#[derive(Debug, Clone, PartialEq, Eq)]
91#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
92pub enum DataTransferResponseStatus {
93 Accepted,
94 Rejected,
95 UnknownMessageId,
96 UnknownVendorId,
97}
98#[derive(Debug, Clone, PartialEq, Eq)]
99#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
100pub enum DiagnosticsStatusNotificationRequestStatus {
101 Idle,
102 Uploaded,
103 UploadFailed,
104 Uploading,
105}
106#[derive(Debug, Clone, PartialEq, Eq)]
107#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
108pub enum FirmwareStatusNotificationRequestStatus {
109 Downloaded,
110 DownloadFailed,
111 Downloading,
112 Idle,
113 InstallationFailed,
114 Installing,
115 Installed,
116}
117#[derive(Debug, Clone, PartialEq, Eq)]
118#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
119pub enum ChargingRateUnit {
120 A,
121 W,
122}
123#[derive(Debug, Clone, PartialEq)]
124#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
125pub struct ChargingSchedulePeriodItem {
126 pub limit: f64,
127 #[cfg_attr(feature = "serde", serde(rename = "numberPhases"))]
128 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
129 pub number_phases: Option<i64>,
130 #[cfg_attr(feature = "serde", serde(rename = "startPeriod"))]
131 pub start_period: i64,
132}
133#[cfg(feature = "alloc")]
134#[derive(Debug, Clone, PartialEq)]
135#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
136pub struct ChargingSchedule {
137 #[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
138 pub charging_rate_unit: ChargingRateUnit,
139 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
140 pub charging_schedule_period: alloc::vec::Vec<ChargingSchedulePeriodItem>,
141 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
142 pub duration: Option<i64>,
143 #[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
144 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
145 pub min_charging_rate: Option<f64>,
146 #[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
147 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
148 pub start_schedule: Option<alloc::string::String>,
149}
150#[cfg(not(feature = "alloc"))]
151#[derive(Debug, Clone, PartialEq)]
152#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
153pub struct ChargingSchedule<
154 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 16usize,
155 const CHARGING_SCHEDULE_START_SCHEDULE_CAP: usize = 1024usize,
156> {
157 #[cfg_attr(feature = "serde", serde(rename = "chargingRateUnit"))]
158 pub charging_rate_unit: ChargingRateUnit,
159 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedulePeriod"))]
160 pub charging_schedule_period: heapless::Vec<
161 ChargingSchedulePeriodItem,
162 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
163 >,
164 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
165 pub duration: Option<i64>,
166 #[cfg_attr(feature = "serde", serde(rename = "minChargingRate"))]
167 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
168 pub min_charging_rate: Option<f64>,
169 #[cfg_attr(feature = "serde", serde(rename = "startSchedule"))]
170 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
171 pub start_schedule: Option<heapless::String<CHARGING_SCHEDULE_START_SCHEDULE_CAP>>,
172}
173#[derive(Debug, Clone, PartialEq, Eq)]
174#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
175pub enum GetCompositeScheduleResponseStatus {
176 Accepted,
177 Rejected,
178}
179#[derive(Debug, Clone, PartialEq, Eq)]
180#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
181pub struct ConfigurationKeyItem {
182 pub key: heapless::String<50usize>,
183 pub readonly: bool,
184 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
185 pub value: Option<heapless::String<500usize>>,
186}
187#[derive(Debug, Clone, PartialEq, Eq)]
188#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
189pub enum Context {
190 #[cfg_attr(feature = "serde", serde(rename = "Interruption.Begin"))]
191 InterruptionBegin,
192 #[cfg_attr(feature = "serde", serde(rename = "Interruption.End"))]
193 InterruptionEnd,
194 #[cfg_attr(feature = "serde", serde(rename = "Sample.Clock"))]
195 SampleClock,
196 #[cfg_attr(feature = "serde", serde(rename = "Sample.Periodic"))]
197 SamplePeriodic,
198 #[cfg_attr(feature = "serde", serde(rename = "Transaction.Begin"))]
199 TransactionBegin,
200 #[cfg_attr(feature = "serde", serde(rename = "Transaction.End"))]
201 TransactionEnd,
202 Trigger,
203 Other,
204}
205#[derive(Debug, Clone, PartialEq, Eq)]
206#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
207pub enum Format {
208 Raw,
209 SignedData,
210}
211#[derive(Debug, Clone, PartialEq, Eq)]
212#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
213pub enum Location {
214 Cable,
215 EV,
216 Inlet,
217 Outlet,
218 Body,
219}
220#[derive(Debug, Clone, PartialEq, Eq)]
221#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
222pub enum Measurand {
223 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Register"))]
224 EnergyActiveExportRegister,
225 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Register"))]
226 EnergyActiveImportRegister,
227 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Register"))]
228 EnergyReactiveExportRegister,
229 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Register"))]
230 EnergyReactiveImportRegister,
231 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Export.Interval"))]
232 EnergyActiveExportInterval,
233 #[cfg_attr(feature = "serde", serde(rename = "Energy.Active.Import.Interval"))]
234 EnergyActiveImportInterval,
235 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Export.Interval"))]
236 EnergyReactiveExportInterval,
237 #[cfg_attr(feature = "serde", serde(rename = "Energy.Reactive.Import.Interval"))]
238 EnergyReactiveImportInterval,
239 #[cfg_attr(feature = "serde", serde(rename = "Power.Active.Export"))]
240 PowerActiveExport,
241 #[cfg_attr(feature = "serde", serde(rename = "Power.Active.Import"))]
242 PowerActiveImport,
243 #[cfg_attr(feature = "serde", serde(rename = "Power.Offered"))]
244 PowerOffered,
245 #[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Export"))]
246 PowerReactiveExport,
247 #[cfg_attr(feature = "serde", serde(rename = "Power.Reactive.Import"))]
248 PowerReactiveImport,
249 #[cfg_attr(feature = "serde", serde(rename = "Power.Factor"))]
250 PowerFactor,
251 #[cfg_attr(feature = "serde", serde(rename = "Current.Import"))]
252 CurrentImport,
253 #[cfg_attr(feature = "serde", serde(rename = "Current.Export"))]
254 CurrentExport,
255 #[cfg_attr(feature = "serde", serde(rename = "Current.Offered"))]
256 CurrentOffered,
257 Voltage,
258 Frequency,
259 Temperature,
260 SoC,
261 RPM,
262}
263#[derive(Debug, Clone, PartialEq, Eq)]
264#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
265pub enum Phase {
266 L1,
267 L2,
268 L3,
269 N,
270 #[cfg_attr(feature = "serde", serde(rename = "L1-N"))]
271 L1N,
272 #[cfg_attr(feature = "serde", serde(rename = "L2-N"))]
273 L2N,
274 #[cfg_attr(feature = "serde", serde(rename = "L3-N"))]
275 L3N,
276 #[cfg_attr(feature = "serde", serde(rename = "L1-L2"))]
277 L1L2,
278 #[cfg_attr(feature = "serde", serde(rename = "L2-L3"))]
279 L2L3,
280 #[cfg_attr(feature = "serde", serde(rename = "L3-L1"))]
281 L3L1,
282}
283#[derive(Debug, Clone, PartialEq, Eq)]
284#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
285pub enum SampledValueItemUnit {
286 Wh,
287 #[cfg_attr(feature = "serde", serde(rename = "kWh"))]
288 KWh,
289 #[cfg_attr(feature = "serde", serde(rename = "varh"))]
290 Varh,
291 #[cfg_attr(feature = "serde", serde(rename = "kvarh"))]
292 Kvarh,
293 W,
294 #[cfg_attr(feature = "serde", serde(rename = "kW"))]
295 KW,
296 VA,
297 #[cfg_attr(feature = "serde", serde(rename = "kVA"))]
298 KVA,
299 #[cfg_attr(feature = "serde", serde(rename = "var"))]
300 Var,
301 #[cfg_attr(feature = "serde", serde(rename = "kvar"))]
302 Kvar,
303 A,
304 V,
305 K,
306 Celcius,
307 Celsius,
308 Fahrenheit,
309 Percent,
310}
311#[cfg(feature = "alloc")]
312#[derive(Debug, Clone, PartialEq, Eq)]
313#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
314pub struct SampledValueItem {
315 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
316 pub context: Option<Context>,
317 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
318 pub format: Option<Format>,
319 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
320 pub location: Option<Location>,
321 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
322 pub measurand: Option<Measurand>,
323 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
324 pub phase: Option<Phase>,
325 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
326 pub unit: Option<SampledValueItemUnit>,
327 pub value: alloc::string::String,
328}
329#[cfg(not(feature = "alloc"))]
330#[derive(Debug, Clone, PartialEq, Eq)]
331#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
332pub struct SampledValueItem<const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize> {
333 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
334 pub context: Option<Context>,
335 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
336 pub format: Option<Format>,
337 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
338 pub location: Option<Location>,
339 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
340 pub measurand: Option<Measurand>,
341 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
342 pub phase: Option<Phase>,
343 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
344 pub unit: Option<SampledValueItemUnit>,
345 pub value: heapless::String<SAMPLED_VALUE_ITEM_VALUE_CAP>,
346}
347#[cfg(feature = "alloc")]
348#[derive(Debug, Clone, PartialEq, Eq)]
349#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
350pub struct MeterValueItem {
351 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
352 pub sampled_value: alloc::vec::Vec<SampledValueItem>,
353 pub timestamp: alloc::string::String,
354}
355#[cfg(not(feature = "alloc"))]
356#[derive(Debug, Clone, PartialEq, Eq)]
357#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
358pub struct MeterValueItem<
359 const METER_VALUE_ITEM_SAMPLED_VALUE_CAP: usize = 16usize,
360 const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
361 const METER_VALUE_ITEM_TIMESTAMP_CAP: usize = 1024usize,
362> {
363 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
364 pub sampled_value: heapless::Vec<
365 SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
366 METER_VALUE_ITEM_SAMPLED_VALUE_CAP,
367 >,
368 pub timestamp: heapless::String<METER_VALUE_ITEM_TIMESTAMP_CAP>,
369}
370#[derive(Debug, Clone, PartialEq, Eq)]
371#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
372pub enum ChargingProfileKind {
373 Absolute,
374 Recurring,
375 Relative,
376}
377#[derive(Debug, Clone, PartialEq, Eq)]
378#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
379pub enum RecurrencyKind {
380 Daily,
381 Weekly,
382}
383#[cfg(feature = "alloc")]
384#[derive(Debug, Clone, PartialEq)]
385#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
386pub struct ChargingProfile {
387 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
388 pub charging_profile_id: i64,
389 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
390 pub charging_profile_kind: ChargingProfileKind,
391 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
392 pub charging_profile_purpose: ChargingProfilePurpose,
393 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
394 pub charging_schedule: ChargingSchedule,
395 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
396 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
397 pub recurrency_kind: Option<RecurrencyKind>,
398 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
399 pub stack_level: i64,
400 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
401 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
402 pub transaction_id: Option<i64>,
403 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
404 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
405 pub valid_from: Option<alloc::string::String>,
406 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
407 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
408 pub valid_to: Option<alloc::string::String>,
409}
410#[cfg(not(feature = "alloc"))]
411#[derive(Debug, Clone, PartialEq)]
412#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
413pub struct ChargingProfile<
414 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 16usize,
415 const CHARGING_SCHEDULE_START_SCHEDULE_CAP: usize = 1024usize,
416 const CHARGING_PROFILE_VALID_FROM_CAP: usize = 1024usize,
417 const CHARGING_PROFILE_VALID_TO_CAP: usize = 1024usize,
418> {
419 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
420 pub charging_profile_id: i64,
421 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
422 pub charging_profile_kind: ChargingProfileKind,
423 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
424 pub charging_profile_purpose: ChargingProfilePurpose,
425 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
426 pub charging_schedule: ChargingSchedule<
427 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
428 CHARGING_SCHEDULE_START_SCHEDULE_CAP,
429 >,
430 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
431 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
432 pub recurrency_kind: Option<RecurrencyKind>,
433 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
434 pub stack_level: i64,
435 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
436 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
437 pub transaction_id: Option<i64>,
438 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
439 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
440 pub valid_from: Option<heapless::String<CHARGING_PROFILE_VALID_FROM_CAP>>,
441 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
442 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
443 pub valid_to: Option<heapless::String<CHARGING_PROFILE_VALID_TO_CAP>>,
444}
445#[derive(Debug, Clone, PartialEq, Eq)]
446#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
447pub enum RemoteStartTransactionResponseStatus {
448 Accepted,
449 Rejected,
450}
451#[derive(Debug, Clone, PartialEq, Eq)]
452#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
453pub enum RemoteStopTransactionResponseStatus {
454 Accepted,
455 Rejected,
456}
457#[derive(Debug, Clone, PartialEq, Eq)]
458#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
459pub enum ReserveNowResponseStatus {
460 Accepted,
461 Faulted,
462 Occupied,
463 Rejected,
464 Unavailable,
465}
466#[derive(Debug, Clone, PartialEq, Eq)]
467#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
468pub enum ResetRequestType {
469 Hard,
470 Soft,
471}
472#[derive(Debug, Clone, PartialEq, Eq)]
473#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
474pub enum ResetResponseStatus {
475 Accepted,
476 Rejected,
477}
478#[cfg(feature = "alloc")]
479#[derive(Debug, Clone, PartialEq, Eq)]
480#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
481pub struct LocalAuthorizationListItem {
482 #[cfg_attr(feature = "serde", serde(rename = "idTag"))]
483 pub id_tag: super::IdTag,
484 #[cfg_attr(feature = "serde", serde(rename = "idTagInfo"))]
485 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
486 pub id_tag_info: Option<IdTagInfo>,
487}
488#[cfg(not(feature = "alloc"))]
489#[derive(Debug, Clone, PartialEq, Eq)]
490#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
491pub struct LocalAuthorizationListItem<
492 const ID_TAG_INFO_EXPIRY_DATE_CAP: usize = 1024usize,
493> {
494 #[cfg_attr(feature = "serde", serde(rename = "idTag"))]
495 pub id_tag: super::IdTag,
496 #[cfg_attr(feature = "serde", serde(rename = "idTagInfo"))]
497 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
498 pub id_tag_info: Option<IdTagInfo<ID_TAG_INFO_EXPIRY_DATE_CAP>>,
499}
500#[derive(Debug, Clone, PartialEq, Eq)]
501#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
502pub enum UpdateType {
503 Differential,
504 Full,
505}
506#[derive(Debug, Clone, PartialEq, Eq)]
507#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
508pub enum SendLocalListResponseStatus {
509 Accepted,
510 Failed,
511 NotSupported,
512 VersionMismatch,
513}
514#[cfg(feature = "alloc")]
515#[derive(Debug, Clone, PartialEq)]
516#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
517pub struct CsChargingProfiles {
518 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
519 pub charging_profile_id: i64,
520 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
521 pub charging_profile_kind: ChargingProfileKind,
522 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
523 pub charging_profile_purpose: ChargingProfilePurpose,
524 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
525 pub charging_schedule: ChargingSchedule,
526 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
527 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
528 pub recurrency_kind: Option<RecurrencyKind>,
529 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
530 pub stack_level: i64,
531 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
532 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
533 pub transaction_id: Option<i64>,
534 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
535 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
536 pub valid_from: Option<alloc::string::String>,
537 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
538 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
539 pub valid_to: Option<alloc::string::String>,
540}
541#[cfg(not(feature = "alloc"))]
542#[derive(Debug, Clone, PartialEq)]
543#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
544pub struct CsChargingProfiles<
545 const CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP: usize = 16usize,
546 const CHARGING_SCHEDULE_START_SCHEDULE_CAP: usize = 1024usize,
547 const CS_CHARGING_PROFILES_VALID_FROM_CAP: usize = 1024usize,
548 const CS_CHARGING_PROFILES_VALID_TO_CAP: usize = 1024usize,
549> {
550 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileId"))]
551 pub charging_profile_id: i64,
552 #[cfg_attr(feature = "serde", serde(rename = "chargingProfileKind"))]
553 pub charging_profile_kind: ChargingProfileKind,
554 #[cfg_attr(feature = "serde", serde(rename = "chargingProfilePurpose"))]
555 pub charging_profile_purpose: ChargingProfilePurpose,
556 #[cfg_attr(feature = "serde", serde(rename = "chargingSchedule"))]
557 pub charging_schedule: ChargingSchedule<
558 CHARGING_SCHEDULE_CHARGING_SCHEDULE_PERIOD_CAP,
559 CHARGING_SCHEDULE_START_SCHEDULE_CAP,
560 >,
561 #[cfg_attr(feature = "serde", serde(rename = "recurrencyKind"))]
562 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
563 pub recurrency_kind: Option<RecurrencyKind>,
564 #[cfg_attr(feature = "serde", serde(rename = "stackLevel"))]
565 pub stack_level: i64,
566 #[cfg_attr(feature = "serde", serde(rename = "transactionId"))]
567 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
568 pub transaction_id: Option<i64>,
569 #[cfg_attr(feature = "serde", serde(rename = "validFrom"))]
570 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
571 pub valid_from: Option<heapless::String<CS_CHARGING_PROFILES_VALID_FROM_CAP>>,
572 #[cfg_attr(feature = "serde", serde(rename = "validTo"))]
573 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
574 pub valid_to: Option<heapless::String<CS_CHARGING_PROFILES_VALID_TO_CAP>>,
575}
576#[derive(Debug, Clone, PartialEq, Eq)]
577#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
578pub enum SetChargingProfileResponseStatus {
579 Accepted,
580 Rejected,
581 NotSupported,
582}
583#[derive(Debug, Clone, PartialEq, Eq)]
584#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
585pub enum ErrorCode {
586 ConnectorLockFailure,
587 EVCommunicationError,
588 GroundFailure,
589 HighTemperature,
590 InternalError,
591 LocalListConflict,
592 NoError,
593 OtherError,
594 OverCurrentFailure,
595 PowerMeterFailure,
596 PowerSwitchFailure,
597 ReaderFailure,
598 ResetFailure,
599 UnderVoltage,
600 OverVoltage,
601 WeakSignal,
602}
603#[derive(Debug, Clone, PartialEq, Eq)]
604#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
605pub enum StatusNotificationRequestStatus {
606 Available,
607 Preparing,
608 Charging,
609 SuspendedEVSE,
610 SuspendedEV,
611 Finishing,
612 Reserved,
613 Unavailable,
614 Faulted,
615}
616#[derive(Debug, Clone, PartialEq, Eq)]
617#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
618pub enum Reason {
619 EmergencyStop,
620 EVDisconnected,
621 HardReset,
622 Local,
623 Other,
624 PowerLoss,
625 Reboot,
626 Remote,
627 SoftReset,
628 UnlockCommand,
629 DeAuthorized,
630}
631#[cfg(feature = "alloc")]
632#[derive(Debug, Clone, PartialEq, Eq)]
633#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
634pub struct TransactionDataItem {
635 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
636 pub sampled_value: alloc::vec::Vec<SampledValueItem>,
637 pub timestamp: alloc::string::String,
638}
639#[cfg(not(feature = "alloc"))]
640#[derive(Debug, Clone, PartialEq, Eq)]
641#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
642pub struct TransactionDataItem<
643 const TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP: usize = 16usize,
644 const SAMPLED_VALUE_ITEM_VALUE_CAP: usize = 1024usize,
645 const TRANSACTION_DATA_ITEM_TIMESTAMP_CAP: usize = 1024usize,
646> {
647 #[cfg_attr(feature = "serde", serde(rename = "sampledValue"))]
648 pub sampled_value: heapless::Vec<
649 SampledValueItem<SAMPLED_VALUE_ITEM_VALUE_CAP>,
650 TRANSACTION_DATA_ITEM_SAMPLED_VALUE_CAP,
651 >,
652 pub timestamp: heapless::String<TRANSACTION_DATA_ITEM_TIMESTAMP_CAP>,
653}
654#[derive(Debug, Clone, PartialEq, Eq)]
655#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
656pub enum RequestedMessage {
657 BootNotification,
658 DiagnosticsStatusNotification,
659 FirmwareStatusNotification,
660 Heartbeat,
661 MeterValues,
662 StatusNotification,
663}
664#[derive(Debug, Clone, PartialEq, Eq)]
665#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
666pub enum TriggerMessageResponseStatus {
667 Accepted,
668 Rejected,
669 NotImplemented,
670}
671#[derive(Debug, Clone, PartialEq, Eq)]
672#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
673pub enum UnlockConnectorResponseStatus {
674 Unlocked,
675 UnlockFailed,
676 NotSupported,
677}