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_V16_OCPP_ENUMS_HPP
#define OCPP_V16_OCPP_ENUMS_HPP
 
#include <iosfwd>
#include <string>
 
namespace ocpp {
namespace v16 {
 
// from: AuthorizeResponse
enum class AuthorizationStatus {
    Accepted,
    Blocked,
    Expired,
    Invalid,
    ConcurrentTx,
};
 
namespace conversions {
std::string authorization_status_to_string(AuthorizationStatus e);
 
AuthorizationStatus string_to_authorization_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const AuthorizationStatus& authorization_status);
 
// from: BootNotificationResponse
enum class RegistrationStatus {
    Accepted,
    Pending,
    Rejected,
};
 
namespace conversions {
std::string registration_status_to_string(RegistrationStatus e);
 
RegistrationStatus string_to_registration_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const RegistrationStatus& registration_status);
 
// from: CancelReservationResponse
enum class CancelReservationStatus {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string cancel_reservation_status_to_string(CancelReservationStatus e);
 
CancelReservationStatus string_to_cancel_reservation_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CancelReservationStatus& cancel_reservation_status);
 
// from: CertificateSignedResponse
enum class CertificateSignedStatusEnumType {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string certificate_signed_status_enum_type_to_string(CertificateSignedStatusEnumType e);
 
CertificateSignedStatusEnumType string_to_certificate_signed_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateSignedStatusEnumType& certificate_signed_status_enum_type);
 
// from: ChangeAvailabilityRequest
enum class AvailabilityType {
    Inoperative,
    Operative,
};
 
namespace conversions {
std::string availability_type_to_string(AvailabilityType e);
 
AvailabilityType string_to_availability_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const AvailabilityType& availability_type);
 
// from: ChangeAvailabilityResponse
enum class AvailabilityStatus {
    Accepted,
    Rejected,
    Scheduled,
};
 
namespace conversions {
std::string availability_status_to_string(AvailabilityStatus e);
 
AvailabilityStatus string_to_availability_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const AvailabilityStatus& availability_status);
 
// from: ChangeConfigurationResponse
enum class ConfigurationStatus {
    Accepted,
    Rejected,
    RebootRequired,
    NotSupported,
};
 
namespace conversions {
std::string configuration_status_to_string(ConfigurationStatus e);
 
ConfigurationStatus string_to_configuration_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ConfigurationStatus& configuration_status);
 
// from: ClearCacheResponse
enum class ClearCacheStatus {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string clear_cache_status_to_string(ClearCacheStatus e);
 
ClearCacheStatus string_to_clear_cache_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ClearCacheStatus& clear_cache_status);
 
// from: ClearChargingProfileRequest
enum class ChargingProfilePurposeType {
    ChargePointMaxProfile,
    TxDefaultProfile,
    TxProfile,
};
 
namespace conversions {
std::string charging_profile_purpose_type_to_string(ChargingProfilePurposeType e);
 
ChargingProfilePurposeType string_to_charging_profile_purpose_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingProfilePurposeType& charging_profile_purpose_type);
 
// from: ClearChargingProfileResponse
enum class ClearChargingProfileStatus {
    Accepted,
    Unknown,
};
 
namespace conversions {
std::string clear_charging_profile_status_to_string(ClearChargingProfileStatus e);
 
ClearChargingProfileStatus string_to_clear_charging_profile_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ClearChargingProfileStatus& clear_charging_profile_status);
 
// from: DataTransferResponse
enum class DataTransferStatus {
    Accepted,
    Rejected,
    UnknownMessageId,
    UnknownVendorId,
};
 
namespace conversions {
std::string data_transfer_status_to_string(DataTransferStatus e);
 
DataTransferStatus string_to_data_transfer_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DataTransferStatus& data_transfer_status);
 
// from: DeleteCertificateRequest
enum class HashAlgorithmEnumType {
    SHA256,
    SHA384,
    SHA512,
};
 
namespace conversions {
std::string hash_algorithm_enum_type_to_string(HashAlgorithmEnumType e);
 
HashAlgorithmEnumType string_to_hash_algorithm_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const HashAlgorithmEnumType& hash_algorithm_enum_type);
 
// from: DeleteCertificateResponse
enum class DeleteCertificateStatusEnumType {
    Accepted,
    Failed,
    NotFound,
};
 
namespace conversions {
std::string delete_certificate_status_enum_type_to_string(DeleteCertificateStatusEnumType e);
 
DeleteCertificateStatusEnumType string_to_delete_certificate_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DeleteCertificateStatusEnumType& delete_certificate_status_enum_type);
 
// from: DiagnosticsStatusNotificationRequest
enum class DiagnosticsStatus {
    Idle,
    Uploaded,
    UploadFailed,
    Uploading,
};
 
namespace conversions {
std::string diagnostics_status_to_string(DiagnosticsStatus e);
 
DiagnosticsStatus string_to_diagnostics_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const DiagnosticsStatus& diagnostics_status);
 
// from: ExtendedTriggerMessageRequest
enum class MessageTriggerEnumType {
    BootNotification,
    LogStatusNotification,
    FirmwareStatusNotification,
    Heartbeat,
    MeterValues,
    SignChargePointCertificate,
    StatusNotification,
};
 
namespace conversions {
std::string message_trigger_enum_type_to_string(MessageTriggerEnumType e);
 
MessageTriggerEnumType string_to_message_trigger_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MessageTriggerEnumType& message_trigger_enum_type);
 
// from: ExtendedTriggerMessageResponse
enum class TriggerMessageStatusEnumType {
    Accepted,
    Rejected,
    NotImplemented,
};
 
namespace conversions {
std::string trigger_message_status_enum_type_to_string(TriggerMessageStatusEnumType e);
 
TriggerMessageStatusEnumType string_to_trigger_message_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const TriggerMessageStatusEnumType& trigger_message_status_enum_type);
 
// from: FirmwareStatusNotificationRequest
enum class FirmwareStatus {
    Downloaded,
    DownloadFailed,
    Downloading,
    Idle,
    InstallationFailed,
    Installing,
    Installed,
};
 
namespace conversions {
std::string firmware_status_to_string(FirmwareStatus e);
 
FirmwareStatus string_to_firmware_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const FirmwareStatus& firmware_status);
 
// from: GetCompositeScheduleRequest
enum class ChargingRateUnit {
    A,
    W,
};
 
namespace conversions {
std::string charging_rate_unit_to_string(ChargingRateUnit e);
 
ChargingRateUnit string_to_charging_rate_unit(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingRateUnit& charging_rate_unit);
 
// from: GetCompositeScheduleResponse
enum class GetCompositeScheduleStatus {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string get_composite_schedule_status_to_string(GetCompositeScheduleStatus e);
 
GetCompositeScheduleStatus string_to_get_composite_schedule_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GetCompositeScheduleStatus& get_composite_schedule_status);
 
// from: GetInstalledCertificateIdsRequest
enum class CertificateUseEnumType {
    CentralSystemRootCertificate,
    ManufacturerRootCertificate,
};
 
namespace conversions {
std::string certificate_use_enum_type_to_string(CertificateUseEnumType e);
 
CertificateUseEnumType string_to_certificate_use_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const CertificateUseEnumType& certificate_use_enum_type);
 
// from: GetInstalledCertificateIdsResponse
enum class GetInstalledCertificateStatusEnumType {
    Accepted,
    NotFound,
};
 
namespace conversions {
std::string get_installed_certificate_status_enum_type_to_string(GetInstalledCertificateStatusEnumType e);
 
GetInstalledCertificateStatusEnumType string_to_get_installed_certificate_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os,
                         const GetInstalledCertificateStatusEnumType& get_installed_certificate_status_enum_type);
 
// from: GetLogRequest
enum class LogEnumType {
    DiagnosticsLog,
    SecurityLog,
};
 
namespace conversions {
std::string log_enum_type_to_string(LogEnumType e);
 
LogEnumType string_to_log_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const LogEnumType& log_enum_type);
 
// from: GetLogResponse
enum class LogStatusEnumType {
    Accepted,
    Rejected,
    AcceptedCanceled,
};
 
namespace conversions {
std::string log_status_enum_type_to_string(LogStatusEnumType e);
 
LogStatusEnumType string_to_log_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const LogStatusEnumType& log_status_enum_type);
 
// from: InstallCertificateResponse
enum class InstallCertificateStatusEnumType {
    Accepted,
    Failed,
    Rejected,
};
 
namespace conversions {
std::string install_certificate_status_enum_type_to_string(InstallCertificateStatusEnumType e);
 
InstallCertificateStatusEnumType string_to_install_certificate_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os,
                         const InstallCertificateStatusEnumType& install_certificate_status_enum_type);
 
// from: LogStatusNotificationRequest
enum class UploadLogStatusEnumType {
    BadMessage,
    Idle,
    NotSupportedOperation,
    PermissionDenied,
    Uploaded,
    UploadFailure,
    Uploading,
};
 
namespace conversions {
std::string upload_log_status_enum_type_to_string(UploadLogStatusEnumType e);
 
UploadLogStatusEnumType string_to_upload_log_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UploadLogStatusEnumType& upload_log_status_enum_type);
 
// from: MeterValuesRequest
enum class ReadingContext {
    Interruption_Begin,
    Interruption_End,
    Sample_Clock,
    Sample_Periodic,
    Transaction_Begin,
    Transaction_End,
    Trigger,
    Other,
};
 
namespace conversions {
std::string reading_context_to_string(ReadingContext e);
 
ReadingContext string_to_reading_context(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReadingContext& reading_context);
 
// from: MeterValuesRequest
enum class ValueFormat {
    Raw,
    SignedData,
};
 
namespace conversions {
std::string value_format_to_string(ValueFormat e);
 
ValueFormat string_to_value_format(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ValueFormat& value_format);
 
// from: MeterValuesRequest
enum class Measurand {
    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_Reactive_Export_Interval,
    Energy_Reactive_Import_Interval,
    Power_Active_Export,
    Power_Active_Import,
    Power_Offered,
    Power_Reactive_Export,
    Power_Reactive_Import,
    Power_Factor,
    Current_Import,
    Current_Export,
    Current_Offered,
    Voltage,
    Frequency,
    Temperature,
    SoC,
    RPM,
};
 
namespace conversions {
std::string measurand_to_string(Measurand e);
 
Measurand string_to_measurand(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const Measurand& measurand);
 
// from: MeterValuesRequest
enum class Phase {
    L1,
    L2,
    L3,
    N,
    L1_N,
    L2_N,
    L3_N,
    L1_L2,
    L2_L3,
    L3_L1,
};
 
namespace conversions {
std::string phase_to_string(Phase e);
 
Phase string_to_phase(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const Phase& phase);
 
// from: MeterValuesRequest
enum class Location {
    Cable,
    EV,
    Inlet,
    Outlet,
    Body,
};
 
namespace conversions {
std::string location_to_string(Location e);
 
Location string_to_location(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const Location& location);
 
// from: MeterValuesRequest
enum class UnitOfMeasure {
    Wh,
    kWh,
    varh,
    kvarh,
    W,
    kW,
    VA,
    kVA,
    var,
    kvar,
    A,
    V,
    K,
    Celcius,
    Celsius,
    Fahrenheit,
    Percent,
};
 
namespace conversions {
std::string unit_of_measure_to_string(UnitOfMeasure e);
 
UnitOfMeasure string_to_unit_of_measure(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UnitOfMeasure& unit_of_measure);
 
// from: RemoteStartTransactionRequest
enum class ChargingProfileKindType {
    Absolute,
    Recurring,
    Relative,
};
 
namespace conversions {
std::string charging_profile_kind_type_to_string(ChargingProfileKindType e);
 
ChargingProfileKindType string_to_charging_profile_kind_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingProfileKindType& charging_profile_kind_type);
 
// from: RemoteStartTransactionRequest
enum class RecurrencyKindType {
    Daily,
    Weekly,
};
 
namespace conversions {
std::string recurrency_kind_type_to_string(RecurrencyKindType e);
 
RecurrencyKindType string_to_recurrency_kind_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const RecurrencyKindType& recurrency_kind_type);
 
// from: RemoteStartTransactionResponse
enum class RemoteStartStopStatus {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string remote_start_stop_status_to_string(RemoteStartStopStatus e);
 
RemoteStartStopStatus string_to_remote_start_stop_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const RemoteStartStopStatus& remote_start_stop_status);
 
// from: ReserveNowResponse
enum class ReservationStatus {
    Accepted,
    Faulted,
    Occupied,
    Rejected,
    Unavailable,
};
 
namespace conversions {
std::string reservation_status_to_string(ReservationStatus e);
 
ReservationStatus string_to_reservation_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ReservationStatus& reservation_status);
 
// from: ResetRequest
enum class ResetType {
    Hard,
    Soft,
};
 
namespace conversions {
std::string reset_type_to_string(ResetType e);
 
ResetType string_to_reset_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ResetType& reset_type);
 
// from: ResetResponse
enum class ResetStatus {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string reset_status_to_string(ResetStatus e);
 
ResetStatus string_to_reset_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ResetStatus& reset_status);
 
// from: SendLocalListRequest
enum class UpdateType {
    Differential,
    Full,
};
 
namespace conversions {
std::string update_type_to_string(UpdateType e);
 
UpdateType string_to_update_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UpdateType& update_type);
 
// from: SendLocalListResponse
enum class UpdateStatus {
    Accepted,
    Failed,
    NotSupported,
    VersionMismatch,
};
 
namespace conversions {
std::string update_status_to_string(UpdateStatus e);
 
UpdateStatus string_to_update_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UpdateStatus& update_status);
 
// from: SetChargingProfileResponse
enum class ChargingProfileStatus {
    Accepted,
    Rejected,
    NotSupported,
};
 
namespace conversions {
std::string charging_profile_status_to_string(ChargingProfileStatus e);
 
ChargingProfileStatus string_to_charging_profile_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargingProfileStatus& charging_profile_status);
 
// from: SignCertificateResponse
enum class GenericStatusEnumType {
    Accepted,
    Rejected,
};
 
namespace conversions {
std::string generic_status_enum_type_to_string(GenericStatusEnumType e);
 
GenericStatusEnumType string_to_generic_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const GenericStatusEnumType& generic_status_enum_type);
 
// from: SignedFirmwareStatusNotificationRequest
enum class FirmwareStatusEnumType {
    Downloaded,
    DownloadFailed,
    Downloading,
    DownloadScheduled,
    DownloadPaused,
    Idle,
    InstallationFailed,
    Installing,
    Installed,
    InstallRebooting,
    InstallScheduled,
    InstallVerificationFailed,
    InvalidSignature,
    SignatureVerified,
};
 
namespace conversions {
std::string firmware_status_enum_type_to_string(FirmwareStatusEnumType e);
 
FirmwareStatusEnumType string_to_firmware_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const FirmwareStatusEnumType& firmware_status_enum_type);
 
// from: SignedUpdateFirmwareResponse
enum class UpdateFirmwareStatusEnumType {
    Accepted,
    Rejected,
    AcceptedCanceled,
    InvalidCertificate,
    RevokedCertificate,
};
 
namespace conversions {
std::string update_firmware_status_enum_type_to_string(UpdateFirmwareStatusEnumType e);
 
UpdateFirmwareStatusEnumType string_to_update_firmware_status_enum_type(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UpdateFirmwareStatusEnumType& update_firmware_status_enum_type);
 
// from: StatusNotificationRequest
enum class ChargePointErrorCode {
    ConnectorLockFailure,
    EVCommunicationError,
    GroundFailure,
    HighTemperature,
    InternalError,
    LocalListConflict,
    NoError,
    OtherError,
    OverCurrentFailure,
    PowerMeterFailure,
    PowerSwitchFailure,
    ReaderFailure,
    ResetFailure,
    UnderVoltage,
    OverVoltage,
    WeakSignal,
};
 
namespace conversions {
std::string charge_point_error_code_to_string(ChargePointErrorCode e);
 
ChargePointErrorCode string_to_charge_point_error_code(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargePointErrorCode& charge_point_error_code);
 
// from: StatusNotificationRequest
enum class ChargePointStatus {
    Available,
    Preparing,
    Charging,
    SuspendedEVSE,
    SuspendedEV,
    Finishing,
    Reserved,
    Unavailable,
    Faulted,
};
 
namespace conversions {
std::string charge_point_status_to_string(ChargePointStatus e);
 
ChargePointStatus string_to_charge_point_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ChargePointStatus& charge_point_status);
 
// from: StopTransactionRequest
enum class Reason {
    EmergencyStop,
    EVDisconnected,
    HardReset,
    Local,
    Other,
    PowerLoss,
    Reboot,
    Remote,
    SoftReset,
    UnlockCommand,
    DeAuthorized,
};
 
namespace conversions {
std::string reason_to_string(Reason e);
 
Reason string_to_reason(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const Reason& reason);
 
// from: TriggerMessageRequest
enum class MessageTrigger {
    BootNotification,
    DiagnosticsStatusNotification,
    FirmwareStatusNotification,
    Heartbeat,
    MeterValues,
    StatusNotification,
};
 
namespace conversions {
std::string message_trigger_to_string(MessageTrigger e);
 
MessageTrigger string_to_message_trigger(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const MessageTrigger& message_trigger);
 
// from: TriggerMessageResponse
enum class TriggerMessageStatus {
    Accepted,
    Rejected,
    NotImplemented,
};
 
namespace conversions {
std::string trigger_message_status_to_string(TriggerMessageStatus e);
 
TriggerMessageStatus string_to_trigger_message_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const TriggerMessageStatus& trigger_message_status);
 
// from: UnlockConnectorResponse
enum class UnlockStatus {
    Unlocked,
    UnlockFailed,
    NotSupported,
};
 
namespace conversions {
std::string unlock_status_to_string(UnlockStatus e);
 
UnlockStatus string_to_unlock_status(const std::string& s);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const UnlockStatus& unlock_status);
 
} // namespace v16
} // namespace ocpp
 
#endif // OCPP_V16_OCPP_ENUMS_HPP