ocpp_enums.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
// This code is generated using the generator in 'src/code_generator/common`, please do not edit manually
 
#ifndef OCPP_V2_OCPP_ENUMS_HPP
#define OCPP_V2_OCPP_ENUMS_HPP
 
#include <iosfwd>
#include <string>
 
namespace ocpp {
namespace v2 {
 
// from: AuthorizeRequest
enum class IdTokenEnum {
    Central,
    eMAID,
    ISO14443,
    ISO15693,
    KeyCode,
    Local,
    MacAddress,
    NoAuthorization,
};
 
namespace conversions {
std::string id_token_enum_to_string(IdTokenEnum e);
 
IdTokenEnum string_to_id_token_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const IdTokenEnum& id_token_enum);
 
// from: AuthorizeRequest
enum class HashAlgorithmEnum {
    SHA256,
    SHA384,
    SHA512,
};
 
namespace conversions {
std::string hash_algorithm_enum_to_string(HashAlgorithmEnum e);
 
HashAlgorithmEnum string_to_hash_algorithm_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const HashAlgorithmEnum& hash_algorithm_enum);
 
// from: AuthorizeResponse
enum class AuthorizationStatusEnum {
    Accepted,
    Blocked,
    ConcurrentTx,
    Expired,
    Invalid,
    NoCredit,
    NotAllowedTypeEVSE,
    NotAtThisLocation,
    NotAtThisTime,
    Unknown,
};
 
namespace conversions {
std::string authorization_status_enum_to_string(AuthorizationStatusEnum e);
 
AuthorizationStatusEnum string_to_authorization_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const AuthorizationStatusEnum& authorization_status_enum);
 
// from: AuthorizeResponse
enum class MessageFormatEnum {
    ASCII,
    HTML,
    URI,
    UTF8,
};
 
namespace conversions {
std::string message_format_enum_to_string(MessageFormatEnum e);
 
MessageFormatEnum string_to_message_format_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MessageFormatEnum& message_format_enum);
 
// from: AuthorizeResponse
enum class AuthorizeCertificateStatusEnum {
    Accepted,
    SignatureError,
    CertificateExpired,
    CertificateRevoked,
    NoCertificateAvailable,
    CertChainError,
    ContractCancelled,
};
 
namespace conversions {
std::string authorize_certificate_status_enum_to_string(AuthorizeCertificateStatusEnum e);
 
AuthorizeCertificateStatusEnum string_to_authorize_certificate_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const AuthorizeCertificateStatusEnum& authorize_certificate_status_enum);
 
// from: BootNotificationRequest
enum class BootReasonEnum {
    ApplicationReset,
    FirmwareUpdate,
    LocalReset,
    PowerUp,
    RemoteReset,
    ScheduledReset,
    Triggered,
    Unknown,
    Watchdog,
};
 
namespace conversions {
std::string boot_reason_enum_to_string(BootReasonEnum e);
 
BootReasonEnum string_to_boot_reason_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const BootReasonEnum& boot_reason_enum);
 
// from: BootNotificationResponse
enum class RegistrationStatusEnum {
    Accepted,
    Pending,
    Rejected,
};
 
namespace conversions {
std::string registration_status_enum_to_string(RegistrationStatusEnum e);
 
RegistrationStatusEnum string_to_registration_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const RegistrationStatusEnum& registration_status_enum);
 
// from: CancelReservationResponse
enum class CancelReservationStatusEnum {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string cancel_reservation_status_enum_to_string(CancelReservationStatusEnum e);
 
CancelReservationStatusEnum string_to_cancel_reservation_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CancelReservationStatusEnum& cancel_reservation_status_enum);
 
// from: CertificateSignedRequest
enum class CertificateSigningUseEnum {
    ChargingStationCertificate,
    V2GCertificate,
};
 
namespace conversions {
std::string certificate_signing_use_enum_to_string(CertificateSigningUseEnum e);
 
CertificateSigningUseEnum string_to_certificate_signing_use_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateSigningUseEnum& certificate_signing_use_enum);
 
// from: CertificateSignedResponse
enum class CertificateSignedStatusEnum {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string certificate_signed_status_enum_to_string(CertificateSignedStatusEnum e);
 
CertificateSignedStatusEnum string_to_certificate_signed_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateSignedStatusEnum& certificate_signed_status_enum);
 
// from: ChangeAvailabilityRequest
enum class OperationalStatusEnum {
    Inoperative,
    Operative,
};
 
namespace conversions {
std::string operational_status_enum_to_string(OperationalStatusEnum e);
 
OperationalStatusEnum string_to_operational_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const OperationalStatusEnum& operational_status_enum);
 
// from: ChangeAvailabilityResponse
enum class ChangeAvailabilityStatusEnum {
    Accepted,
    Rejected,
    Scheduled,
};
 
namespace conversions {
std::string change_availability_status_enum_to_string(ChangeAvailabilityStatusEnum e);
 
ChangeAvailabilityStatusEnum string_to_change_availability_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChangeAvailabilityStatusEnum& change_availability_status_enum);
 
// from: ClearCacheResponse
enum class ClearCacheStatusEnum {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string clear_cache_status_enum_to_string(ClearCacheStatusEnum e);
 
ClearCacheStatusEnum string_to_clear_cache_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ClearCacheStatusEnum& clear_cache_status_enum);
 
// from: ClearChargingProfileRequest
enum class ChargingProfilePurposeEnum {
    ChargingStationExternalConstraints,
    ChargingStationMaxProfile,
    TxDefaultProfile,
    TxProfile,
};
 
namespace conversions {
std::string charging_profile_purpose_enum_to_string(ChargingProfilePurposeEnum e);
 
ChargingProfilePurposeEnum string_to_charging_profile_purpose_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingProfilePurposeEnum& charging_profile_purpose_enum);
 
// from: ClearChargingProfileResponse
enum class ClearChargingProfileStatusEnum {
    Accepted,
    Unknown,
};
 
namespace conversions {
std::string clear_charging_profile_status_enum_to_string(ClearChargingProfileStatusEnum e);
 
ClearChargingProfileStatusEnum string_to_clear_charging_profile_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ClearChargingProfileStatusEnum& clear_charging_profile_status_enum);
 
// from: ClearDisplayMessageResponse
enum class ClearMessageStatusEnum {
    Accepted,
    Unknown,
};
 
namespace conversions {
std::string clear_message_status_enum_to_string(ClearMessageStatusEnum e);
 
ClearMessageStatusEnum string_to_clear_message_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ClearMessageStatusEnum& clear_message_status_enum);
 
// from: ClearVariableMonitoringResponse
enum class ClearMonitoringStatusEnum {
    Accepted,
    Rejected,
    NotFound,
};
 
namespace conversions {
std::string clear_monitoring_status_enum_to_string(ClearMonitoringStatusEnum e);
 
ClearMonitoringStatusEnum string_to_clear_monitoring_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ClearMonitoringStatusEnum& clear_monitoring_status_enum);
 
// from: ClearedChargingLimitRequest
enum class ChargingLimitSourceEnum {
    EMS,
    Other,
    SO,
    CSO,
};
 
namespace conversions {
std::string charging_limit_source_enum_to_string(ChargingLimitSourceEnum e);
 
ChargingLimitSourceEnum string_to_charging_limit_source_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingLimitSourceEnum& charging_limit_source_enum);
 
// from: CustomerInformationResponse
enum class CustomerInformationStatusEnum {
    Accepted,
    Rejected,
    Invalid,
};
 
namespace conversions {
std::string customer_information_status_enum_to_string(CustomerInformationStatusEnum e);
 
CustomerInformationStatusEnum string_to_customer_information_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CustomerInformationStatusEnum& customer_information_status_enum);
 
// from: DataTransferResponse
enum class DataTransferStatusEnum {
    Accepted,
    Rejected,
    UnknownMessageId,
    UnknownVendorId,
};
 
namespace conversions {
std::string data_transfer_status_enum_to_string(DataTransferStatusEnum e);
 
DataTransferStatusEnum string_to_data_transfer_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DataTransferStatusEnum& data_transfer_status_enum);
 
// from: DeleteCertificateResponse
enum class DeleteCertificateStatusEnum {
    Accepted,
    Failed,
    NotFound,
};
 
namespace conversions {
std::string delete_certificate_status_enum_to_string(DeleteCertificateStatusEnum e);
 
DeleteCertificateStatusEnum string_to_delete_certificate_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DeleteCertificateStatusEnum& delete_certificate_status_enum);
 
// from: FirmwareStatusNotificationRequest
enum class FirmwareStatusEnum {
    Downloaded,
    DownloadFailed,
    Downloading,
    DownloadScheduled,
    DownloadPaused,
    Idle,
    InstallationFailed,
    Installing,
    Installed,
    InstallRebooting,
    InstallScheduled,
    InstallVerificationFailed,
    InvalidSignature,
    SignatureVerified,
};
 
namespace conversions {
std::string firmware_status_enum_to_string(FirmwareStatusEnum e);
 
FirmwareStatusEnum string_to_firmware_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const FirmwareStatusEnum& firmware_status_enum);
 
// from: Get15118EVCertificateRequest
enum class CertificateActionEnum {
    Install,
    Update,
};
 
namespace conversions {
std::string certificate_action_enum_to_string(CertificateActionEnum e);
 
CertificateActionEnum string_to_certificate_action_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateActionEnum& certificate_action_enum);
 
// from: Get15118EVCertificateResponse
enum class Iso15118EVCertificateStatusEnum {
    Accepted,
    Failed,
};
 
namespace conversions {
std::string iso15118evcertificate_status_enum_to_string(Iso15118EVCertificateStatusEnum e);
 
Iso15118EVCertificateStatusEnum string_to_iso15118evcertificate_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const Iso15118EVCertificateStatusEnum& iso15118evcertificate_status_enum);
 
// from: GetBaseReportRequest
enum class ReportBaseEnum {
    ConfigurationInventory,
    FullInventory,
    SummaryInventory,
};
 
namespace conversions {
std::string report_base_enum_to_string(ReportBaseEnum e);
 
ReportBaseEnum string_to_report_base_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReportBaseEnum& report_base_enum);
 
// from: GetBaseReportResponse
enum class GenericDeviceModelStatusEnum {
    Accepted,
    Rejected,
    NotSupported,
    EmptyResultSet,
};
 
namespace conversions {
std::string generic_device_model_status_enum_to_string(GenericDeviceModelStatusEnum e);
 
GenericDeviceModelStatusEnum string_to_generic_device_model_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GenericDeviceModelStatusEnum& generic_device_model_status_enum);
 
// from: GetCertificateStatusResponse
enum class GetCertificateStatusEnum {
    Accepted,
    Failed,
};
 
namespace conversions {
std::string get_certificate_status_enum_to_string(GetCertificateStatusEnum e);
 
GetCertificateStatusEnum string_to_get_certificate_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GetCertificateStatusEnum& get_certificate_status_enum);
 
// from: GetChargingProfilesResponse
enum class GetChargingProfileStatusEnum {
    Accepted,
    NoProfiles,
};
 
namespace conversions {
std::string get_charging_profile_status_enum_to_string(GetChargingProfileStatusEnum e);
 
GetChargingProfileStatusEnum string_to_get_charging_profile_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GetChargingProfileStatusEnum& get_charging_profile_status_enum);
 
// from: GetCompositeScheduleRequest
enum class ChargingRateUnitEnum {
    W,
    A,
};
 
namespace conversions {
std::string charging_rate_unit_enum_to_string(ChargingRateUnitEnum e);
 
ChargingRateUnitEnum string_to_charging_rate_unit_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingRateUnitEnum& charging_rate_unit_enum);
 
// from: GetCompositeScheduleResponse
enum class GenericStatusEnum {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string generic_status_enum_to_string(GenericStatusEnum e);
 
GenericStatusEnum string_to_generic_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GenericStatusEnum& generic_status_enum);
 
// from: GetDisplayMessagesRequest
enum class MessagePriorityEnum {
    AlwaysFront,
    InFront,
    NormalCycle,
};
 
namespace conversions {
std::string message_priority_enum_to_string(MessagePriorityEnum e);
 
MessagePriorityEnum string_to_message_priority_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MessagePriorityEnum& message_priority_enum);
 
// from: GetDisplayMessagesRequest
enum class MessageStateEnum {
    Charging,
    Faulted,
    Idle,
    Unavailable,
};
 
namespace conversions {
std::string message_state_enum_to_string(MessageStateEnum e);
 
MessageStateEnum string_to_message_state_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MessageStateEnum& message_state_enum);
 
// from: GetDisplayMessagesResponse
enum class GetDisplayMessagesStatusEnum {
    Accepted,
    Unknown,
};
 
namespace conversions {
std::string get_display_messages_status_enum_to_string(GetDisplayMessagesStatusEnum e);
 
GetDisplayMessagesStatusEnum string_to_get_display_messages_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GetDisplayMessagesStatusEnum& get_display_messages_status_enum);
 
// from: GetInstalledCertificateIdsRequest
enum class GetCertificateIdUseEnum {
    V2GRootCertificate,
    MORootCertificate,
    CSMSRootCertificate,
    V2GCertificateChain,
    ManufacturerRootCertificate,
};
 
namespace conversions {
std::string get_certificate_id_use_enum_to_string(GetCertificateIdUseEnum e);
 
GetCertificateIdUseEnum string_to_get_certificate_id_use_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GetCertificateIdUseEnum& get_certificate_id_use_enum);
 
// from: GetInstalledCertificateIdsResponse
enum class GetInstalledCertificateStatusEnum {
    Accepted,
    NotFound,
};
 
namespace conversions {
std::string get_installed_certificate_status_enum_to_string(GetInstalledCertificateStatusEnum e);
 
GetInstalledCertificateStatusEnum string_to_get_installed_certificate_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os,
                         const GetInstalledCertificateStatusEnum& get_installed_certificate_status_enum);
 
// from: GetLogRequest
enum class LogEnum {
    DiagnosticsLog,
    SecurityLog,
};
 
namespace conversions {
std::string log_enum_to_string(LogEnum e);
 
LogEnum string_to_log_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const LogEnum& log_enum);
 
// from: GetLogResponse
enum class LogStatusEnum {
    Accepted,
    Rejected,
    AcceptedCanceled,
};
 
namespace conversions {
std::string log_status_enum_to_string(LogStatusEnum e);
 
LogStatusEnum string_to_log_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const LogStatusEnum& log_status_enum);
 
// from: GetMonitoringReportRequest
enum class MonitoringCriterionEnum {
    ThresholdMonitoring,
    DeltaMonitoring,
    PeriodicMonitoring,
};
 
namespace conversions {
std::string monitoring_criterion_enum_to_string(MonitoringCriterionEnum e);
 
MonitoringCriterionEnum string_to_monitoring_criterion_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MonitoringCriterionEnum& monitoring_criterion_enum);
 
// from: GetReportRequest
enum class ComponentCriterionEnum {
    Active,
    Available,
    Enabled,
    Problem,
};
 
namespace conversions {
std::string component_criterion_enum_to_string(ComponentCriterionEnum e);
 
ComponentCriterionEnum string_to_component_criterion_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ComponentCriterionEnum& component_criterion_enum);
 
// from: GetVariablesRequest
enum class AttributeEnum {
    Actual,
    Target,
    MinSet,
    MaxSet,
};
 
namespace conversions {
std::string attribute_enum_to_string(AttributeEnum e);
 
AttributeEnum string_to_attribute_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const AttributeEnum& attribute_enum);
 
// from: GetVariablesResponse
enum class GetVariableStatusEnum {
    Accepted,
    Rejected,
    UnknownComponent,
    UnknownVariable,
    NotSupportedAttributeType,
};
 
namespace conversions {
std::string get_variable_status_enum_to_string(GetVariableStatusEnum e);
 
GetVariableStatusEnum string_to_get_variable_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GetVariableStatusEnum& get_variable_status_enum);
 
// from: InstallCertificateRequest
enum class InstallCertificateUseEnum {
    V2GRootCertificate,
    MORootCertificate,
    CSMSRootCertificate,
    ManufacturerRootCertificate,
};
 
namespace conversions {
std::string install_certificate_use_enum_to_string(InstallCertificateUseEnum e);
 
InstallCertificateUseEnum string_to_install_certificate_use_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const InstallCertificateUseEnum& install_certificate_use_enum);
 
// from: InstallCertificateResponse
enum class InstallCertificateStatusEnum {
    Accepted,
    Rejected,
    Failed,
};
 
namespace conversions {
std::string install_certificate_status_enum_to_string(InstallCertificateStatusEnum e);
 
InstallCertificateStatusEnum string_to_install_certificate_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const InstallCertificateStatusEnum& install_certificate_status_enum);
 
// from: LogStatusNotificationRequest
enum class UploadLogStatusEnum {
    BadMessage,
    Idle,
    NotSupportedOperation,
    PermissionDenied,
    Uploaded,
    UploadFailure,
    Uploading,
    AcceptedCanceled,
};
 
namespace conversions {
std::string upload_log_status_enum_to_string(UploadLogStatusEnum e);
 
UploadLogStatusEnum string_to_upload_log_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UploadLogStatusEnum& upload_log_status_enum);
 
// from: MeterValuesRequest
enum class ReadingContextEnum {
    Interruption_Begin,
    Interruption_End,
    Other,
    Sample_Clock,
    Sample_Periodic,
    Transaction_Begin,
    Transaction_End,
    Trigger,
};
 
namespace conversions {
std::string reading_context_enum_to_string(ReadingContextEnum e);
 
ReadingContextEnum string_to_reading_context_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReadingContextEnum& reading_context_enum);
 
// from: MeterValuesRequest
enum class MeasurandEnum {
    Current_Export,
    Current_Import,
    Current_Offered,
    Energy_Active_Export_Register,
    Energy_Active_Import_Register,
    Energy_Reactive_Export_Register,
    Energy_Reactive_Import_Register,
    Energy_Active_Export_Interval,
    Energy_Active_Import_Interval,
    Energy_Active_Net,
    Energy_Reactive_Export_Interval,
    Energy_Reactive_Import_Interval,
    Energy_Reactive_Net,
    Energy_Apparent_Net,
    Energy_Apparent_Import,
    Energy_Apparent_Export,
    Frequency,
    Power_Active_Export,
    Power_Active_Import,
    Power_Factor,
    Power_Offered,
    Power_Reactive_Export,
    Power_Reactive_Import,
    SoC,
    Voltage,
};
 
namespace conversions {
std::string measurand_enum_to_string(MeasurandEnum e);
 
MeasurandEnum string_to_measurand_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MeasurandEnum& measurand_enum);
 
// from: MeterValuesRequest
enum class PhaseEnum {
    L1,
    L2,
    L3,
    N,
    L1_N,
    L2_N,
    L3_N,
    L1_L2,
    L2_L3,
    L3_L1,
};
 
namespace conversions {
std::string phase_enum_to_string(PhaseEnum e);
 
PhaseEnum string_to_phase_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const PhaseEnum& phase_enum);
 
// from: MeterValuesRequest
enum class LocationEnum {
    Body,
    Cable,
    EV,
    Inlet,
    Outlet,
};
 
namespace conversions {
std::string location_enum_to_string(LocationEnum e);
 
LocationEnum string_to_location_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const LocationEnum& location_enum);
 
// from: NotifyChargingLimitRequest
enum class CostKindEnum {
    CarbonDioxideEmission,
    RelativePricePercentage,
    RenewableGenerationPercentage,
};
 
namespace conversions {
std::string cost_kind_enum_to_string(CostKindEnum e);
 
CostKindEnum string_to_cost_kind_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CostKindEnum& cost_kind_enum);
 
// from: NotifyEVChargingNeedsRequest
enum class EnergyTransferModeEnum {
    DC,
    AC_single_phase,
    AC_two_phase,
    AC_three_phase,
};
 
namespace conversions {
std::string energy_transfer_mode_enum_to_string(EnergyTransferModeEnum e);
 
EnergyTransferModeEnum string_to_energy_transfer_mode_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const EnergyTransferModeEnum& energy_transfer_mode_enum);
 
// from: NotifyEVChargingNeedsResponse
enum class NotifyEVChargingNeedsStatusEnum {
    Accepted,
    Rejected,
    Processing,
};
 
namespace conversions {
std::string notify_evcharging_needs_status_enum_to_string(NotifyEVChargingNeedsStatusEnum e);
 
NotifyEVChargingNeedsStatusEnum string_to_notify_evcharging_needs_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const NotifyEVChargingNeedsStatusEnum& notify_evcharging_needs_status_enum);
 
// from: NotifyEventRequest
enum class EventTriggerEnum {
    Alerting,
    Delta,
    Periodic,
};
 
namespace conversions {
std::string event_trigger_enum_to_string(EventTriggerEnum e);
 
EventTriggerEnum string_to_event_trigger_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const EventTriggerEnum& event_trigger_enum);
 
// from: NotifyEventRequest
enum class EventNotificationEnum {
    HardWiredNotification,
    HardWiredMonitor,
    PreconfiguredMonitor,
    CustomMonitor,
};
 
namespace conversions {
std::string event_notification_enum_to_string(EventNotificationEnum e);
 
EventNotificationEnum string_to_event_notification_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const EventNotificationEnum& event_notification_enum);
 
// from: NotifyMonitoringReportRequest
enum class MonitorEnum {
    UpperThreshold,
    LowerThreshold,
    Delta,
    Periodic,
    PeriodicClockAligned,
};
 
namespace conversions {
std::string monitor_enum_to_string(MonitorEnum e);
 
MonitorEnum string_to_monitor_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MonitorEnum& monitor_enum);
 
// from: NotifyReportRequest
enum class MutabilityEnum {
    ReadOnly,
    WriteOnly,
    ReadWrite,
};
 
namespace conversions {
std::string mutability_enum_to_string(MutabilityEnum e);
 
MutabilityEnum string_to_mutability_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MutabilityEnum& mutability_enum);
 
// from: NotifyReportRequest
enum class DataEnum {
    string,
    decimal,
    integer,
    dateTime,
    boolean,
    OptionList,
    SequenceList,
    MemberList,
};
 
namespace conversions {
std::string data_enum_to_string(DataEnum e);
 
DataEnum string_to_data_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DataEnum& data_enum);
 
// from: PublishFirmwareStatusNotificationRequest
enum class PublishFirmwareStatusEnum {
    Idle,
    DownloadScheduled,
    Downloading,
    Downloaded,
    Published,
    DownloadFailed,
    DownloadPaused,
    InvalidChecksum,
    ChecksumVerified,
    PublishFailed,
};
 
namespace conversions {
std::string publish_firmware_status_enum_to_string(PublishFirmwareStatusEnum e);
 
PublishFirmwareStatusEnum string_to_publish_firmware_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const PublishFirmwareStatusEnum& publish_firmware_status_enum);
 
// from: ReportChargingProfilesRequest
enum class ChargingProfileKindEnum {
    Absolute,
    Recurring,
    Relative,
};
 
namespace conversions {
std::string charging_profile_kind_enum_to_string(ChargingProfileKindEnum e);
 
ChargingProfileKindEnum string_to_charging_profile_kind_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingProfileKindEnum& charging_profile_kind_enum);
 
// from: ReportChargingProfilesRequest
enum class RecurrencyKindEnum {
    Daily,
    Weekly,
};
 
namespace conversions {
std::string recurrency_kind_enum_to_string(RecurrencyKindEnum e);
 
RecurrencyKindEnum string_to_recurrency_kind_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const RecurrencyKindEnum& recurrency_kind_enum);
 
// from: RequestStartTransactionResponse
enum class RequestStartStopStatusEnum {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string request_start_stop_status_enum_to_string(RequestStartStopStatusEnum e);
 
RequestStartStopStatusEnum string_to_request_start_stop_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const RequestStartStopStatusEnum& request_start_stop_status_enum);
 
// from: ReservationStatusUpdateRequest
enum class ReservationUpdateStatusEnum {
    Expired,
    Removed,
};
 
namespace conversions {
std::string reservation_update_status_enum_to_string(ReservationUpdateStatusEnum e);
 
ReservationUpdateStatusEnum string_to_reservation_update_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReservationUpdateStatusEnum& reservation_update_status_enum);
 
// from: ReserveNowRequest
enum class ConnectorEnum {
    cCCS1,
    cCCS2,
    cG105,
    cTesla,
    cType1,
    cType2,
    s309_1P_16A,
    s309_1P_32A,
    s309_3P_16A,
    s309_3P_32A,
    sBS1361,
    sCEE_7_7,
    sType2,
    sType3,
    Other1PhMax16A,
    Other1PhOver16A,
    Other3Ph,
    Pan,
    wInductive,
    wResonant,
    Undetermined,
    Unknown,
};
 
namespace conversions {
std::string connector_enum_to_string(ConnectorEnum e);
 
ConnectorEnum string_to_connector_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ConnectorEnum& connector_enum);
 
// from: ReserveNowResponse
enum class ReserveNowStatusEnum {
    Accepted,
    Faulted,
    Occupied,
    Rejected,
    Unavailable,
};
 
namespace conversions {
std::string reserve_now_status_enum_to_string(ReserveNowStatusEnum e);
 
ReserveNowStatusEnum string_to_reserve_now_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReserveNowStatusEnum& reserve_now_status_enum);
 
// from: ResetRequest
enum class ResetEnum {
    Immediate,
    OnIdle,
};
 
namespace conversions {
std::string reset_enum_to_string(ResetEnum e);
 
ResetEnum string_to_reset_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ResetEnum& reset_enum);
 
// from: ResetResponse
enum class ResetStatusEnum {
    Accepted,
    Rejected,
    Scheduled,
};
 
namespace conversions {
std::string reset_status_enum_to_string(ResetStatusEnum e);
 
ResetStatusEnum string_to_reset_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ResetStatusEnum& reset_status_enum);
 
// from: SendLocalListRequest
enum class UpdateEnum {
    Differential,
    Full,
};
 
namespace conversions {
std::string update_enum_to_string(UpdateEnum e);
 
UpdateEnum string_to_update_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UpdateEnum& update_enum);
 
// from: SendLocalListResponse
enum class SendLocalListStatusEnum {
    Accepted,
    Failed,
    VersionMismatch,
};
 
namespace conversions {
std::string send_local_list_status_enum_to_string(SendLocalListStatusEnum e);
 
SendLocalListStatusEnum string_to_send_local_list_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const SendLocalListStatusEnum& send_local_list_status_enum);
 
// from: SetChargingProfileResponse
enum class ChargingProfileStatusEnum {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string charging_profile_status_enum_to_string(ChargingProfileStatusEnum e);
 
ChargingProfileStatusEnum string_to_charging_profile_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingProfileStatusEnum& charging_profile_status_enum);
 
// from: SetDisplayMessageResponse
enum class DisplayMessageStatusEnum {
    Accepted,
    NotSupportedMessageFormat,
    Rejected,
    NotSupportedPriority,
    NotSupportedState,
    UnknownTransaction,
};
 
namespace conversions {
std::string display_message_status_enum_to_string(DisplayMessageStatusEnum e);
 
DisplayMessageStatusEnum string_to_display_message_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DisplayMessageStatusEnum& display_message_status_enum);
 
// from: SetMonitoringBaseRequest
enum class MonitoringBaseEnum {
    All,
    FactoryDefault,
    HardWiredOnly,
};
 
namespace conversions {
std::string monitoring_base_enum_to_string(MonitoringBaseEnum e);
 
MonitoringBaseEnum string_to_monitoring_base_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MonitoringBaseEnum& monitoring_base_enum);
 
// from: SetNetworkProfileRequest
enum class APNAuthenticationEnum {
    CHAP,
    NONE,
    PAP,
    AUTO,
};
 
namespace conversions {
std::string apnauthentication_enum_to_string(APNAuthenticationEnum e);
 
APNAuthenticationEnum string_to_apnauthentication_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const APNAuthenticationEnum& apnauthentication_enum);
 
// from: SetNetworkProfileRequest
enum class OCPPVersionEnum {
    OCPP12,
    OCPP15,
    OCPP16,
    OCPP20,
};
 
namespace conversions {
std::string ocppversion_enum_to_string(OCPPVersionEnum e);
 
OCPPVersionEnum string_to_ocppversion_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const OCPPVersionEnum& ocppversion_enum);
 
// from: SetNetworkProfileRequest
enum class OCPPTransportEnum {
    JSON,
    SOAP,
};
 
namespace conversions {
std::string ocpptransport_enum_to_string(OCPPTransportEnum e);
 
OCPPTransportEnum string_to_ocpptransport_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const OCPPTransportEnum& ocpptransport_enum);
 
// from: SetNetworkProfileRequest
enum class OCPPInterfaceEnum {
    Wired0,
    Wired1,
    Wired2,
    Wired3,
    Wireless0,
    Wireless1,
    Wireless2,
    Wireless3,
};
 
namespace conversions {
std::string ocppinterface_enum_to_string(OCPPInterfaceEnum e);
 
OCPPInterfaceEnum string_to_ocppinterface_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const OCPPInterfaceEnum& ocppinterface_enum);
 
// from: SetNetworkProfileRequest
enum class VPNEnum {
    IKEv2,
    IPSec,
    L2TP,
    PPTP,
};
 
namespace conversions {
std::string vpnenum_to_string(VPNEnum e);
 
VPNEnum string_to_vpnenum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const VPNEnum& vpnenum);
 
// from: SetNetworkProfileResponse
enum class SetNetworkProfileStatusEnum {
    Accepted,
    Rejected,
    Failed,
};
 
namespace conversions {
std::string set_network_profile_status_enum_to_string(SetNetworkProfileStatusEnum e);
 
SetNetworkProfileStatusEnum string_to_set_network_profile_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const SetNetworkProfileStatusEnum& set_network_profile_status_enum);
 
// from: SetVariableMonitoringResponse
enum class SetMonitoringStatusEnum {
    Accepted,
    UnknownComponent,
    UnknownVariable,
    UnsupportedMonitorType,
    Rejected,
    Duplicate,
};
 
namespace conversions {
std::string set_monitoring_status_enum_to_string(SetMonitoringStatusEnum e);
 
SetMonitoringStatusEnum string_to_set_monitoring_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const SetMonitoringStatusEnum& set_monitoring_status_enum);
 
// from: SetVariablesResponse
enum class SetVariableStatusEnum {
    Accepted,
    Rejected,
    UnknownComponent,
    UnknownVariable,
    NotSupportedAttributeType,
    RebootRequired,
};
 
namespace conversions {
std::string set_variable_status_enum_to_string(SetVariableStatusEnum e);
 
SetVariableStatusEnum string_to_set_variable_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const SetVariableStatusEnum& set_variable_status_enum);
 
// from: StatusNotificationRequest
enum class ConnectorStatusEnum {
    Available,
    Occupied,
    Reserved,
    Unavailable,
    Faulted,
};
 
namespace conversions {
std::string connector_status_enum_to_string(ConnectorStatusEnum e);
 
ConnectorStatusEnum string_to_connector_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ConnectorStatusEnum& connector_status_enum);
 
// from: TransactionEventRequest
enum class TransactionEventEnum {
    Ended,
    Started,
    Updated,
};
 
namespace conversions {
std::string transaction_event_enum_to_string(TransactionEventEnum e);
 
TransactionEventEnum string_to_transaction_event_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const TransactionEventEnum& transaction_event_enum);
 
// from: TransactionEventRequest
enum class TriggerReasonEnum {
    Authorized,
    CablePluggedIn,
    ChargingRateChanged,
    ChargingStateChanged,
    Deauthorized,
    EnergyLimitReached,
    EVCommunicationLost,
    EVConnectTimeout,
    MeterValueClock,
    MeterValuePeriodic,
    TimeLimitReached,
    Trigger,
    UnlockCommand,
    StopAuthorized,
    EVDeparted,
    EVDetected,
    RemoteStop,
    RemoteStart,
    AbnormalCondition,
    SignedDataReceived,
    ResetCommand,
};
 
namespace conversions {
std::string trigger_reason_enum_to_string(TriggerReasonEnum e);
 
TriggerReasonEnum string_to_trigger_reason_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const TriggerReasonEnum& trigger_reason_enum);
 
// from: TransactionEventRequest
enum class ChargingStateEnum {
    Charging,
    EVConnected,
    SuspendedEV,
    SuspendedEVSE,
    Idle,
};
 
namespace conversions {
std::string charging_state_enum_to_string(ChargingStateEnum e);
 
ChargingStateEnum string_to_charging_state_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingStateEnum& charging_state_enum);
 
// from: TransactionEventRequest
enum class ReasonEnum {
    DeAuthorized,
    EmergencyStop,
    EnergyLimitReached,
    EVDisconnected,
    GroundFault,
    ImmediateReset,
    Local,
    LocalOutOfCredit,
    MasterPass,
    Other,
    OvercurrentFault,
    PowerLoss,
    PowerQuality,
    Reboot,
    Remote,
    SOCLimitReached,
    StoppedByEV,
    TimeLimitReached,
    Timeout,
};
 
namespace conversions {
std::string reason_enum_to_string(ReasonEnum e);
 
ReasonEnum string_to_reason_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReasonEnum& reason_enum);
 
// from: TriggerMessageRequest
enum class MessageTriggerEnum {
    BootNotification,
    LogStatusNotification,
    FirmwareStatusNotification,
    Heartbeat,
    MeterValues,
    SignChargingStationCertificate,
    SignV2GCertificate,
    StatusNotification,
    TransactionEvent,
    SignCombinedCertificate,
    PublishFirmwareStatusNotification,
};
 
namespace conversions {
std::string message_trigger_enum_to_string(MessageTriggerEnum e);
 
MessageTriggerEnum string_to_message_trigger_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MessageTriggerEnum& message_trigger_enum);
 
// from: TriggerMessageResponse
enum class TriggerMessageStatusEnum {
    Accepted,
    Rejected,
    NotImplemented,
};
 
namespace conversions {
std::string trigger_message_status_enum_to_string(TriggerMessageStatusEnum e);
 
TriggerMessageStatusEnum string_to_trigger_message_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const TriggerMessageStatusEnum& trigger_message_status_enum);
 
// from: UnlockConnectorResponse
enum class UnlockStatusEnum {
    Unlocked,
    UnlockFailed,
    OngoingAuthorizedTransaction,
    UnknownConnector,
};
 
namespace conversions {
std::string unlock_status_enum_to_string(UnlockStatusEnum e);
 
UnlockStatusEnum string_to_unlock_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UnlockStatusEnum& unlock_status_enum);
 
// from: UnpublishFirmwareResponse
enum class UnpublishFirmwareStatusEnum {
    DownloadOngoing,
    NoFirmware,
    Unpublished,
};
 
namespace conversions {
std::string unpublish_firmware_status_enum_to_string(UnpublishFirmwareStatusEnum e);
 
UnpublishFirmwareStatusEnum string_to_unpublish_firmware_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UnpublishFirmwareStatusEnum& unpublish_firmware_status_enum);
 
// from: UpdateFirmwareResponse
enum class UpdateFirmwareStatusEnum {
    Accepted,
    Rejected,
    AcceptedCanceled,
    InvalidCertificate,
    RevokedCertificate,
};
 
namespace conversions {
std::string update_firmware_status_enum_to_string(UpdateFirmwareStatusEnum e);
 
UpdateFirmwareStatusEnum string_to_update_firmware_status_enum(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UpdateFirmwareStatusEnum& update_firmware_status_enum);
 
} // namespace v2
} // namespace ocpp
 
#endif // OCPP_V2_OCPP_ENUMS_HPP