#include "ocpp21_enum.h"

/// @brief  3.1
/// @param string 
/// @return 
int APNAuthenticationEnumType_fromString(const char *string)
{
    if (string)
    {
        if (strcmp(string, "PAP")==0) return APNAuthenticationEnumType_PAP;
        if (strcmp(string, "CHAP")==0) return APNAuthenticationEnumType_CHAP;
        if (strcmp(string, "NONE")==0) return APNAuthenticationEnumType_NONE;
        if (strcmp(string, "AUTO")==0) return APNAuthenticationEnumType_AUTO;
    }
    return 0;
}

const char* APNAuthenticationEnumType_toString(int type)
{
    switch(type)
    {
        case APNAuthenticationEnumType_PAP: return "PAP";
        case APNAuthenticationEnumType_CHAP: return "CHAP";
        case APNAuthenticationEnumType_NONE: return "NONE";
        case APNAuthenticationEnumType_AUTO: return "AUTO";
    }
    return NULL;
}

/// @brief 3.2
/// @param string 
/// @return 
int AttributeEnumType_fromString(const char *string)
{
    if (string)
    {
        if (strcmp(string, "Actual")==0) return AttributeEnumType_Actual;
        if (strnmp(string, "Target")==0) return AttributeEnumType_Target;
        if (strcmp(string, "MinSet")==0) return AttributeEnumType_MinSet;
        if (strcmp(string, "MaxSet")==0) return AttributeEnumType_MaxSet;
    }
    return 0;
}

const char* AttributeEnumType_toString(int type)
{
    switch(type)
    {
        case AttributeEnumType_Actual: return "Actual";
        case AttributeEnumType_Target: return "Target";
        case AttributeEnumType_MinSet: return "MinSet";
        case AttributeEnumType_MaxSet: return "MaxSet";
    }
    return NULL;
}

/// @brief 3.3
/// @param string 
/// @return 
int AuthorizationStatusEnumType_fromString(const char *string)
{
    if (string)
    {
        if (strcmp(string, "Accepted")==0) return AuthorizationStatusEnumType_Accepted;
        if (strcmp(string, "Blocked")==0) return AuthorizationStatusEnumType_Blocked;
        if (strcmp(string, "ConcurrentTx")==0) return AuthorizationStatusEnumType_ConcurrentTx;
        if (strcmp(string, "Expired")==0) return AuthorizationStatusEnumType_Expired;
        if (strcmp(string, "NoCredit")==0) return AuthorizationStatusEnumType_NoCredit;
        if (strcmp(string, "NotAllowedTypeEVSE")==0) return AuthorizationStatusEnumType_NotAllowedTypeEVSE;
        if (strcmp(string, "NotAtThisLocation")==0) return AuthorizationStatusEnumType_NotAtThisLocation;
        if (strcmp(string, "NotAtThisTime")==0) return AuthorizationStatusEnumType_NotAtThisTime;
        if (strcmp(string, "Unknown")==0) return AuthorizationStatusEnumType_Unknown;
    }
    return 0;
}

const char* AuthorizationStatusEnumType_toString(int type)
{
    switch(type)
    {
        case AuthorizationStatusEnumType_Accepted: return "Accepted";
        case AuthorizationStatusEnumType_Blocked: return "Blocked";
        case AuthorizationStatusEnumType_ConcurrentTx: return "ConcurrentTx";
        case AuthorizationStatusEnumType_Expired: return "Expired";
        case AuthorizationStatusEnumType_NoCredit: return "NoCredit";
        case AuthorizationStatusEnumType_NotAllowedTypeEVSE: return "NotAllowedTypeEVSE";
        case AuthorizationStatusEnumType_NotAtThisLocation: return "NotAtThisLocation";
        case AuthorizationStatusEnumType_NotAtThisTime: return "NotAtThisTime";
        case AuthorizationStatusEnumType_Unknown: return "Unknown";
    }
    return NULL;
}

/// @brief 3.4
/// @param string 
/// @return 
int AuthorizeCertificateStatusEnumType_fromString(const char *string)
{
    if (string)
    {
        if (strcmp(string, "Accepted")==0) return AuthorizeCertificateStatusEnumType_Accepted;
        if (strcmp(string, "SignatureError")==0) return AuthorizeCertificateStatusEnumType_SignatureError;
        if (strcmp(string, "CertificateExpired")==0) return AuthorizeCertificateStatusEnumType_CertificateExpired;
        if (strcmp(string, "CertificateRevoked")==0) return AuthorizeCertificateStatusEnumType_CertificateRevoked;
        if (strcmp(string, "NoCertificateAvailable")==0) return AuthorizeCertificateStatusEnumType_NoCertificateAvailable;
        if (strcmp(string, "CertChainError")==0) return AuthorizeCertificateStatusEnumType_CertChainError;
        if (strcmp(string, "ContractCancelled")==0) return AuthorizeCertificateStatusEnumType_ContractCancelled;

    }
    return 0;
}

const char* AuthorizeCertificateStatusEnumType_toString(int type)
{
    switch(type)
    {
        case AuthorizeCertificateStatusEnumType_Accepted: return "Accepted";
        case AuthorizeCertificateStatusEnumType_SignatureError: return "SignatureError";
        case AuthorizeCertificateStatusEnumType_CertificateExpired: return "CertificateExpired";
        case AuthorizeCertificateStatusEnumType_CertificateRevoked: return "CertificateRevoked";
        case AuthorizeCertificateStatusEnumType_NoCertificateAvailable: return "NoCertificateAvailable";
        case AuthorizeCertificateStatusEnumType_CertChainError: return "CertChainError";
        case AuthorizeCertificateStatusEnumType_ContractCancelled: return "ContractCancelled";
    }
    return NULL;
}

/// @brief 3.5
/// @param string 
/// @return 
int BatterySwapEventEnumType_fromString(const char *string)
{
    if (string)
    {
        if (strcmp(string, "BatteryIn")==0) return BatterySwapEventEnumType_BatteryIn;
        if (strcmp(string, "BatteryOut")==0) return BatterySwapEventEnumType_BatteryOut;
        if (strcmp(string, "BatteryOutTimeout")==0) return BatterySwapEventEnumType_BatteryOutTimeout;


    }
    return 0;
}

const char* BatterySwapEventEnumType_toString(int type)
{
    switch(type)
    {
        case BatterySwapEventEnumType_BatteryIn: return "BatteryIn";
        case BatterySwapEventEnumType_BatteryOut: return "BatteryOut";
        case BatterySwapEventEnumType_BatteryOutTimeout: return "BatteryOutTimeout";
    }
    return NULL;
}

// 3.6
int BootReasonEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ApplicationReset") == 0) return BootReasonEnumType_ApplicationReset;
        if (strcmp(string, "FirmwareUpdate") == 0) return BootReasonEnumType_FirmwareUpdate;
        if (strcmp(string, "LocalReset") == 0) return BootReasonEnumType_LocalReset;
        if (strcmp(string, "PowerUp") == 0) return BootReasonEnumType_PowerUp;
        if (strcmp(string, "RemoteReset") == 0) return BootReasonEnumType_RemoteReset;
        if (strcmp(string, "ScheduledReset") == 0) return BootReasonEnumType_ScheduledReset;
        if (strcmp(string, "Triggered") == 0) return BootReasonEnumType_Triggered;
        if (strcmp(string, "Unknown") == 0) return BootReasonEnumType_Unknown;
        if (strcmp(string, "Watchdog") == 0) return BootReasonEnumType_Watchdog;
    }
    return 0;
}

const char* BootReasonEnumType_toString(int type)
{
    switch (type) {
        case BootReasonEnumType_ApplicationReset: return "ApplicationReset";
        case BootReasonEnumType_FirmwareUpdate: return "FirmwareUpdate";
        case BootReasonEnumType_LocalReset: return "LocalReset";
        case BootReasonEnumType_PowerUp: return "PowerUp";
        case BootReasonEnumType_RemoteReset: return "RemoteReset";
        case BootReasonEnumType_ScheduledReset: return "ScheduledReset";
        case BootReasonEnumType_Triggered: return "Triggered";
        case BootReasonEnumType_Unknown: return "Unknown";
        case BootReasonEnumType_Watchdog: return "Watchdog";
    }
    return NULL;
}

//3.7
int CancelReservationStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return CancelReservationStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return CancelReservationStatusEnumType_Rejected;
    }
    return 0;
}

const char* CancelReservationStatusEnumType_toString(int type)
{
    switch (type) {
        case CancelReservationStatusEnumType_Accepted: return "Accepted";
        case CancelReservationStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

//3.8
int CertificateActionEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Install") == 0) return CertificateActionEnumType_Install;
        if (strcmp(string, "Update") == 0) return CertificateActionEnumType_Update;
    }
    return 0;
}

const char* CertificateActionEnumType_toString(int type)
{
    switch (type) {
        case CertificateActionEnumType_Install: return "Install";
        case CertificateActionEnumType_Update: return "Update";
    }
    return NULL;
}

//3.9
int CertificateSignedStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return CertificateSignedStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return CertificateSignedStatusEnumType_Rejected;
    }
    return 0;
}

const char* CertificateSignedStatusEnumType_toString(int type)
{
    switch (type) {
        case CertificateSignedStatusEnumType_Accepted: return "Accepted";
        case CertificateSignedStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

//3.10
int CertificateSigningUseEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ChargingStationCertificate") == 0) return CertificateSigningUseEnumType_ChargingStationCertificate;
        if (strcmp(string, "V2GCertificate") == 0) return CertificateSigningUseEnumType_V2GCertificate;
        if (strcmp(string, "V2G20Certificate") == 0) return CertificateSigningUseEnumType_V2G20Certificate;
    }
    return 0;
}

const char* CertificateSigningUseEnumType_toString(int type)
{
    switch (type) {
        case CertificateSigningUseEnumType_ChargingStationCertificate: return "ChargingStationCertificate";
        case CertificateSigningUseEnumType_V2GCertificate: return "V2GCertificate";
        case CertificateSigningUseEnumType_V2G20Certificate: return "V2G20Certificate";
    }
    return NULL;
}

//3.11
int CertificateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Good") == 0) return CertificateStatusEnumType_Good;
        if (strcmp(string, "Revoked") == 0) return CertificateStatusEnumType_Revoked;
        if (strcmp(string, "Unknown") == 0) return CertificateStatusEnumType_Unknown;
        if (strcmp(string, "Failed") == 0) return CertificateStatusEnumType_Failed;
    }
    return 0;
}

const char* CertificateStatusEnumType_toString(int type)
{
    switch(type) {
        case CertificateStatusEnumType_Good: return "Good";
        case CertificateStatusEnumType_Revoked: return "Revoked";
        case CertificateStatusEnumType_Unknown: return "Unknown";
        case CertificateStatusEnumType_Failed: return "Failed";
    }
    return NULL;
}

// 3.12 
int CertificateStatusSourceEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "CRL") == 0) return CertificateStatusSourceEnumType_CRL;
        if (strcmp(string, "OCSP") == 0)  return CertificateStatusSourceEnumType_OCSP;
    }
    return 0;
}

const char* CertificateStatusSourceEnumType_toString(int type)
{
    switch(type) {
        case CertificateStatusSourceEnumType_CRL:return "CRL";
        case CertificateStatusSourceEnumType_OCSP:return "OCSP";
    }
    return NULL;
}

// 3.13 
int ChangeAvailabilityStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ChangeAvailabilityStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return ChangeAvailabilityStatusEnumType_Rejected;
        if (strcmp(string, "Scheduled") == 0) return ChangeAvailabilityStatusEnumType_Scheduled;
    }
    return 0;
}

const char* ChangeAvailabilityStatusEnumType_toString(int type)
{
    switch (type) {
        case ChangeAvailabilityStatusEnumType_Accepted: return "Accepted";
        case ChangeAvailabilityStatusEnumType_Rejected: return "Rejected";
        case ChangeAvailabilityStatusEnumType_Scheduled: return "Scheduled";
    }
    return NULL;
}

// 3.14 
int ChargingProfileKindEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Absolute") == 0) return ChargingProfileKindEnumType_Absolute;
        if (strcmp(string, "Recurring") == 0) return ChargingProfileKindEnumType_Recurring;
        if (strcmp(string, "Relative") == 0) return ChargingProfileKindEnumType_Relative;
        if (strcmp(string, "Dynamic") == 0) return ChargingProfileKindEnumType_Dynamic;
    }
    return 0;
}

const char* ChargingProfileKindEnumType_toString(int type)
{
    switch (type) {
        case ChargingProfileKindEnumType_Absolute: return "Absolute";
        case ChargingProfileKindEnumType_Recurring: return "Recurring";
        case ChargingProfileKindEnumType_Relative: return "Relative";
        case ChargingProfileKindEnumType_Dynamic:return  "Dynamic";
    }
    return NULL;
}

// 3.15 
int ChargingProfilePurposeEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ChargingStationExternalConstraints") == 0) return ChargingProfilePurposeEnumType_ChargingStationExternalConstraints;
        if (strcmp(string, "ChargingStationMaxProfile") == 0) return ChargingProfilePurposeEnumType_ChargingStationMaxProfile;
        if (strcmp(string, "TxDefaultProfile") == 0) return ChargingProfilePurposeEnumType_TxDefaultProfile;
        if (strcmp(string, "TxProfile") == 0) return ChargingProfilePurposeEnumType_TxProfile;
        if (strcmp(string, "PriorityCharging") == 0) return ChargingProfilePurposeEnumType_PriorityCharging;
        if (strcmp(string, "LocalGeneration") == 0) return ChargingProfilePurposeEnumType_LocalGeneration;
    }
    return 0;
}

const char* ChargingProfilePurposeEnumType_toString(int type)
{
    switch (type) {
        case ChargingProfilePurposeEnumType_ChargingStationExternalConstraints: return "ChargingStationExternalConstraints";
        case ChargingProfilePurposeEnumType_ChargingStationMaxProfile: return "ChargingStationMaxProfile";
        case ChargingProfilePurposeEnumType_TxDefaultProfile: return "TxDefaultProfile";
        case ChargingProfilePurposeEnumType_TxProfile: return "TxProfile";
        case ChargingProfilePurposeEnumType_PriorityCharging: return "PriorityCharging";
        case ChargingProfilePurposeEnumType_LocalGeneration: return "LocalGeneration";
    }
    return NULL;
}

//3.16
int ChargingProfileStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ChargingProfileStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return ChargingProfileStatusEnumType_Rejected;
    }
    return 0;
}

const char* ChargingProfileStatusEnumType_toString(int type)
{
    switch(type) {
        case ChargingProfileStatusEnumType_Accepted: return "Accepted";
        case ChargingProfileStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

//3.17
int ChargingRateUnitEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "W") == 0) return ChargingRateUnitEnumType_W;
        if (strcmp(string, "A") == 0) return ChargingRateUnitEnumType_A;
    }
    return 0;
}

const char* ChargingRateUnitEnumType_toString(int type)
{
    switch(type) {
        case ChargingRateUnitEnumType_W: return "W";
        case ChargingRateUnitEnumType_A: return "A";
    }
    return NULL;
}

//3.18
int ChargingStateEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "EVConnected") == 0) return ChargingStateEnumType_EVConnected;
        if (strcmp(string, "Charging") == 0) return ChargingStateEnumType_Charging;
        if (strcmp(string, "SuspendedEV") == 0) return ChargingStateEnumType_SuspendedEV;
        if (strcmp(string, "SuspendedEVSE") == 0) return ChargingStateEnumType_SuspendedEVSE;
        if (strcmp(string, "Idle") == 0) return ChargingStateEnumType_Idle;
    }
    return 0;
}

const char* ChargingStateEnumType_toString(int type)
{
    switch(type) {
        case ChargingStateEnumType_EVConnected: return "EVConnected";
        case ChargingStateEnumType_Charging: return "Charging";
        case ChargingStateEnumType_SuspendedEV: return "SuspendedEV";
        case ChargingStateEnumType_SuspendedEVSE: return "SuspendedEVSE";
        case ChargingStateEnumType_Idle: return "Idle";
    }
    return NULL;
}

//3.19
int ClearCacheStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ClearCacheStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return ClearCacheStatusEnumType_Rejected;
    }
    return 0;
}

const char* ClearCacheStatusEnumType_toString(int type)
{
    switch(type) {
        case ClearCacheStatusEnumType_Accepted: return "Accepted";
        case ClearCacheStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

//3.20
int ClearChargingProfileStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ClearChargingProfileStatusEnumType_Accepted;
        if (strcmp(string, "Unknown") == 0) return ClearChargingProfileStatusEnumType_Unknown;
    }
    return 0;
}

const char* ClearChargingProfileStatusEnumType_toString(int type)
{
    switch(type) {
        case ClearChargingProfileStatusEnumType_Accepted: return "Accepted";
        case ClearChargingProfileStatusEnumType_Unknown: return "Unknown";
    }
    return NULL;
}

//3.21
int ClearMessageStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ClearMessageStatusEnumType_Accepted;
        if (strcmp(string, "Unknown") == 0) return ClearMessageStatusEnumType_Unknown;
        if (strcmp(string, "Rejected") == 0) return ClearMessageStatusEnumType_Rejected;
    }
    return 0;
}

const char* ClearMessageStatusEnumType_toString(int type)
{
    switch(type) {
        case ClearMessageStatusEnumType_Accepted: return "Accepted";
        case ClearMessageStatusEnumType_Unknown: return "Unknown";
        case ClearMessageStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

//3.22
int ClearMonitoringStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ClearMonitoringStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return ClearMonitoringStatusEnumType_Rejected;
        if (strcmp(string, "NotFound") == 0) return ClearMonitoringStatusEnumType_NotFound;
    }
    return 0;
}

const char* ClearMonitoringStatusEnumType_toString(int type)
{
    switch(type) {
        case ClearMonitoringStatusEnumType_Accepted: return "Accepted";
        case ClearMonitoringStatusEnumType_Rejected: return "Rejected";
        case ClearMonitoringStatusEnumType_NotFound: return "NotFound";
    }
    return NULL;
}

//3.23
int ComponentCriterionEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Active") == 0) return ComponentCriterionEnumType_Active;
        if (strcmp(string, "Available") == 0) return ComponentCriterionEnumType_Available;
        if (strcmp(string, "Enabled") == 0) return ComponentCriterionEnumType_Enabled;
        if (strcmp(string, "Problem") == 0) return ComponentCriterionEnumType_Problem;
    }
    return 0;
}

const char* ComponentCriterionEnumType_toString(int type)
{
    switch(type) {
        case ComponentCriterionEnumType_Active: return "Active";
        case ComponentCriterionEnumType_Available: return "Available";
        case ComponentCriterionEnumType_Enabled: return "Enabled";
        case ComponentCriterionEnumType_Problem: return "Problem";
    }
    return NULL;
}

//3.24
int ConnectorStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Available") == 0) return ConnectorStatusEnumType_Available;
        if (strcmp(string, "Occupied") == 0) return ConnectorStatusEnumType_Occupied;
        if (strcmp(string, "Reserved") == 0) return ConnectorStatusEnumType_Reserved;
        if (strcmp(string, "Unavailable") == 0) return ConnectorStatusEnumType_Unavailable;
        if (strcmp(string, "Faulted") == 0) return ConnectorStatusEnumType_Faulted;
    }
    return 0;
}

const char* ConnectorStatusEnumType_toString(int type)
{
    switch(type) {
        case ConnectorStatusEnumType_Available: return "Available";
        case ConnectorStatusEnumType_Occupied: return "Occupied";
        case ConnectorStatusEnumType_Reserved: return "Reserved";
        case ConnectorStatusEnumType_Unavailable: return "Unavailable";
        case ConnectorStatusEnumType_Faulted: return "Faulted";
    }
    return NULL;
}

//3.25
int ControlModeEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ScheduledControl") == 0) return ControlModeEnumType_ScheduledControl;
        if (strcmp(string, "DynamicControl") == 0) return ControlModeEnumType_DynamicControl;
    }
    return 0;
}

const char* ControlModeEnumType_toString(int type)
{
    switch(type) {
        case ControlModeEnumType_ScheduledControl: return "ScheduledControl";
        case ControlModeEnumType_DynamicControl: return "DynamicControl";
    }
    return NULL;
}

//3.26
int CostDimensionEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Energy") == 0) return CostDimensionEnumType_Energy;
        if (strcmp(string, "MaxCurrent") == 0) return CostDimensionEnumType_MaxCurrent;
        if (strcmp(string, "MinCurrent") == 0) return CostDimensionEnumType_MinCurrent;
        if (strcmp(string, "MaxPower") == 0) return CostDimensionEnumType_MaxPower;
        if (strcmp(string, "MinPower") == 0) return CostDimensionEnumType_MinPower;
        if (strcmp(string, "IdleTIme") == 0) return CostDimensionEnumType_IdleTIme;
        if (strcmp(string, "ChargingTime") == 0) return CostDimensionEnumType_ChargingTime;
    }
    return 0;
}

const char* CostDimensionEnumType_toString(int type)
{
    switch(type) {
        case CostDimensionEnumType_Energy: return "Energy";
        case CostDimensionEnumType_MaxCurrent: return "MaxCurrent";
        case CostDimensionEnumType_MinCurrent: return "MinCurrent";
        case CostDimensionEnumType_MaxPower: return "MaxPower";
        case CostDimensionEnumType_MinPower: return "MinPower";
        case CostDimensionEnumType_IdleTIme: return "IdleTIme";
        case CostDimensionEnumType_ChargingTime: return "ChargingTime";
    }
    return NULL;
}

//3.27
int CostKindEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "CarbonDioxideEmission") == 0) return CostKindEnumType_CarbonDioxideEmission;
        if (strcmp(string, "RelativePricePercentage") == 0) return CostKindEnumType_RelativePricePercentage;
        if (strcmp(string, "RenewableGenerationPercentage") == 0) return CostKindEnumType_RenewableGenerationPercentage;
    }
    return 0;
}

const char* CostKindEnumType_toString(int type)
{
    switch(type) {
        case CostKindEnumType_CarbonDioxideEmission: return "CarbonDioxideEmission";
        case CostKindEnumType_RelativePricePercentage: return "RelativePricePercentage";
        case CostKindEnumType_RenewableGenerationPercentage: return "RenewableGenerationPercentage";
    }
    return NULL;
}

//3.28
int CustomerInformationStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return CustomerInformationStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return CustomerInformationStatusEnumType_Rejected;
        if (strcmp(string, "Invalid") == 0) return CustomerInformationStatusEnumType_Invalid;
    }
    return 0;
}

const char* CustomerInformationStatusEnumType_toString(int type)
{
    switch(type) {
        case CustomerInformationStatusEnumType_Accepted: return "Accepted";
        case CustomerInformationStatusEnumType_Rejected: return "Rejected";
        case CustomerInformationStatusEnumType_Invalid: return "Invalid";
    }
    return NULL;
}

//3.29
int DataEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "string") == 0) return DataEnumType_string;
        if (strcmp(string, "decimal") == 0) return DataEnumType_decimal;
        if (strcmp(string, "integer") == 0) return DataEnumType_integer;
        if (strcmp(string, "dateTime") == 0) return DataEnumType_dateTime;
        if (strcmp(string, "boolean") == 0) return DataEnumType_boolean;
        if (strcmp(string, "OptionList") == 0) return DataEnumType_OptionList;
        if (strcmp(string, "SequenceList") == 0) return DataEnumType_SequenceList;
        if (strcmp(string, "MemberList") == 0) return DataEnumType_MemberList;
    }
    return 0;
}

const char* DataEnumType_toString(int type)
{
    switch(type) {
        case DataEnumType_string: return "string";
        case DataEnumType_decimal: return "decimal";
        case DataEnumType_integer: return "integer";
        case DataEnumType_dateTime: return "dateTime";
        case DataEnumType_boolean: return "boolean";
        case DataEnumType_OptionList: return "OptionList";
        case DataEnumType_SequenceList: return "SequenceList";
        case DataEnumType_MemberList: return "MemberList";
    }
    return NULL;
}

//3.30
int DataTransferStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return DataTransferStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return DataTransferStatusEnumType_Rejected;
        if (strcmp(string, "UnknownMessageId") == 0) return DataTransferStatusEnumType_UnknownMessageId;
        if (strcmp(string, "UnknownVendorId") == 0) return DataTransferStatusEnumType_UnknownVendorId;
    }
    return 0;
}

const char* DataTransferStatusEnumType_toString(int type)
{
    switch(type) {
        case DataTransferStatusEnumType_Accepted: return "Accepted";
        case DataTransferStatusEnumType_Rejected: return "Rejected";
        case DataTransferStatusEnumType_UnknownMessageId: return "UnknownMessageId";
        case DataTransferStatusEnumType_UnknownVendorId: return "UnknownVendorId";
    }
    return NULL;
}

//3.31
int DayOfWeekEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Monday") == 0) return DayOfWeekEnumType_Monday;
        if (strcmp(string, "Tuesday") == 0) return DayOfWeekEnumType_Tuesday;
        if (strcmp(string, "Wednesday") == 0) return DayOfWeekEnumType_Wednesday;
        if (strcmp(string, "Thursday") == 0) return DayOfWeekEnumType_Thursday;
        if (strcmp(string, "Friday") == 0) return DayOfWeekEnumType_Friday;
        if (strcmp(string, "Saturday") == 0) return DayOfWeekEnumType_Saturday;
        if (strcmp(string, "Sunday") == 0) return DayOfWeekEnumType_Sunday;
    }
    return 0;
}

const char* DayOfWeekEnumType_toString(int type)
{
    switch(type) {
        case DayOfWeekEnumType_Monday: return "Monday";
        case DayOfWeekEnumType_Tuesday: return "Tuesday";
        case DayOfWeekEnumType_Wednesday: return "Wednesday";
        case DayOfWeekEnumType_Thursday: return "Thursday";
        case DayOfWeekEnumType_Friday: return "Friday";
        case DayOfWeekEnumType_Saturday: return "Saturday";
        case DayOfWeekEnumType_Sunday: return "Sunday";
    }
    return NULL;
}

//3.32
int DeleteCertificateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return DeleteCertificateStatusEnumType_Accepted;
        if (strcmp(string, "Failed") == 0) return DeleteCertificateStatusEnumType_Failed;
        if (strcmp(string, "NotFound") == 0) return DeleteCertificateStatusEnumType_NotFound;
    }
    return 0;
}

const char* DeleteCertificateStatusEnumType_toString(int type)
{
    switch(type) {
        case DeleteCertificateStatusEnumType_Accepted: return "Accepted";
        case DeleteCertificateStatusEnumType_Failed: return "Failed";
        case DeleteCertificateStatusEnumType_NotFound: return "NotFound";
    }
    return NULL;
}

//3.33
int DERControlEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "EnterService") == 0) return DERControlEnumType_EnterService;
        if (strcmp(string, "FreqDroop") == 0) return DERControlEnumType_FreqDroop;
        if (strcmp(string, "FreqWatt") == 0) return DERControlEnumType_FreqWatt;
        if (strcmp(string, "FixedPFAbsorb") == 0) return DERControlEnumType_FixedPFAbsorb;
        if (strcmp(string, "FixedPFInject") == 0) return DERControlEnumType_FixedPFInject;
        if (strcmp(string, "FixedVar") == 0) return DERControlEnumType_FixedVar;
        if (strcmp(string, "Gradients") == 0) return DERControlEnumType_Gradients;
        if (strcmp(string, "HFMustTrip") == 0) return DERControlEnumType_HFMustTrip;
        if (strcmp(string, "HFMayTrip") == 0) return DERControlEnumType_HFMayTrip;
        if (strcmp(string, "HVMustTrip") == 0) return DERControlEnumType_HVMustTrip;
        if (strcmp(string, "HVMomCess") == 0) return DERControlEnumType_HVMomCess;
        if (strcmp(string, "HVMayTrip") == 0) return DERControlEnumType_HVMayTrip;
        if (strcmp(string, "LimitMaxDischarge") == 0) return DERControlEnumType_LimitMaxDischarge;
        if (strcmp(string, "LFMustTrip") == 0) return DERControlEnumType_LFMustTrip;
        if (strcmp(string, "LVMustTrip") == 0) return DERControlEnumType_LVMustTrip;
        if (strcmp(string, "LVMomCess") == 0) return DERControlEnumType_LVMomCess;
        if (strcmp(string, "LVMayTrip") == 0) return DERControlEnumType_LVMayTrip;
        if (strcmp(string, "PowerMonitoringMustTrip") == 0) return DERControlEnumType_PowerMonitoringMustTrip;
        if (strcmp(string, "VoltVar") == 0) return DERControlEnumType_VoltVar;
        if (strcmp(string, "VoltWatt") == 0) return DERControlEnumType_VoltWatt;
        if (strcmp(string, "WattPF") == 0) return DERControlEnumType_WattPF;
        if (strcmp(string, "WattVar") == 0) return DERControlEnumType_WattVar;
    }
    return 0;
}

const char* DERControlEnumType_toString(int type)
{
    switch(type) {
        case DERControlEnumType_EnterService: return "EnterService";
        case DERControlEnumType_FreqDroop: return "FreqDroop";
        case DERControlEnumType_FreqWatt: return "FreqWatt";
        case DERControlEnumType_FixedPFAbsorb: return "FixedPFAbsorb";
        case DERControlEnumType_FixedPFInject: return "FixedPFInject";
        case DERControlEnumType_FixedVar: return "FixedVar";
        case DERControlEnumType_Gradients: return "Gradients";
        case DERControlEnumType_HFMustTrip: return "HFMustTrip";
        case DERControlEnumType_HFMayTrip: return "HFMayTrip";
        case DERControlEnumType_HVMustTrip: return "HVMustTrip";
        case DERControlEnumType_HVMomCess: return "HVMomCess";
        case DERControlEnumType_HVMayTrip: return "HVMayTrip";
        case DERControlEnumType_LimitMaxDischarge: return "LimitMaxDischarge";
        case DERControlEnumType_LFMustTrip: return "LFMustTrip";
        case DERControlEnumType_LVMustTrip: return "LVMustTrip";
        case DERControlEnumType_LVMomCess: return "LVMomCess";
        case DERControlEnumType_LVMayTrip: return "LVMayTrip";
        case DERControlEnumType_PowerMonitoringMustTrip: return "PowerMonitoringMustTrip";
        case DERControlEnumType_VoltVar: return "VoltVar";
        case DERControlEnumType_VoltWatt: return "VoltWatt";
        case DERControlEnumType_WattPF: return "WattPF";
        case DERControlEnumType_WattVar: return "WattVar";
    }
    return NULL;
}

//3.34
int DERControlStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return DERControlStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return DERControlStatusEnumType_Rejected;
        if (strcmp(string, "NotSupported") == 0) return DERControlStatusEnumType_NotSupported;
        if (strcmp(string, "NotFound") == 0) return DERControlStatusEnumType_NotFound;
    }
    return 0;
}

const char* DERControlStatusEnumType_toString(int type)
{
    switch(type) {
        case DERControlStatusEnumType_Accepted: return "Accepted";
        case DERControlStatusEnumType_Rejected: return "Rejected";
        case DERControlStatusEnumType_NotSupported: return "NotSupported";
        case DERControlStatusEnumType_NotFound: return "NotFound";
    }
    return NULL;
}

//3.35
int DERUnitEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Not_Applicable") == 0) return DERUnitEnumType_Not_Applicable;
        if (strcmp(string, "PctMaxW") == 0) return DERUnitEnumType_PctMaxW;
        if (strcmp(string, "PctMaxVar") == 0) return DERUnitEnumType_PctMaxVar;
        if (strcmp(string, "PctWAvail") == 0) return DERUnitEnumType_PctWAvail;
        if (strcmp(string, "PctVarAvail") == 0) return DERUnitEnumType_PctVarAvail;
        if (strcmp(string, "PctEffectiveV") == 0) return DERUnitEnumType_PctEffectiveV;
    }
    return 0;
}

const char* DERUnitEnumType_toString(int type)
{
    switch(type) {
        case DERUnitEnumType_Not_Applicable: return "Not_Applicable";
        case DERUnitEnumType_PctMaxW: return "PctMaxW";
        case DERUnitEnumType_PctMaxVar: return "PctMaxVar";
        case DERUnitEnumType_PctWAvail: return "PctWAvail";
        case DERUnitEnumType_PctVarAvail: return "PctVarAvail";
        case DERUnitEnumType_PctEffectiveV: return "PctEffectiveV";
    }
    return NULL;
}

//3.36
int DisplayMessageStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return DisplayMessageStatusEnumType_Accepted;
        if (strcmp(string, "NotSupportedMessageFormat") == 0) return DisplayMessageStatusEnumType_NotSupportedMessageFormat;
        if (strcmp(string, "Rejected") == 0) return DisplayMessageStatusEnumType_Rejected;
        if (strcmp(string, "NotSupportedPriority") == 0) return DisplayMessageStatusEnumType_NotSupportedPriority;
        if (strcmp(string, "NotSupportedState") == 0) return DisplayMessageStatusEnumType_NotSupportedState;
        if (strcmp(string, "UnknownTransaction") == 0) return DisplayMessageStatusEnumType_UnknownTransaction;
        if (strcmp(string, "LanguageNotSupported") == 0) return DisplayMessageStatusEnumType_LanguageNotSupported;
    }
    return 0;
}

const char* DisplayMessageStatusEnumType_toString(int type)
{
    switch(type) {
        case DisplayMessageStatusEnumType_Accepted: return "Accepted";
        case DisplayMessageStatusEnumType_NotSupportedMessageFormat: return "NotSupportedMessageFormat";
        case DisplayMessageStatusEnumType_Rejected: return "Rejected";
        case DisplayMessageStatusEnumType_NotSupportedPriority: return "NotSupportedPriority";
        case DisplayMessageStatusEnumType_NotSupportedState: return "NotSupportedState";
        case DisplayMessageStatusEnumType_UnknownTransaction: return "UnknownTransaction";
        case DisplayMessageStatusEnumType_LanguageNotSupported: return "LanguageNotSupported";
    }
    return NULL;
}

// 3.37
int EnergyTransferModeEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "AC_single_phase") == 0) return EnergyTransferModeEnumType_AC_single_phase;
        if (strcmp(string, "AC_two_phase") == 0) return EnergyTransferModeEnumType_AC_two_phase;
        if (strcmp(string, "AC_three_phase") == 0) return EnergyTransferModeEnumType_AC_three_phase;
        if (strcmp(string, "DC") == 0) return EnergyTransferModeEnumType_DC;
        if (strcmp(string, "AC_BPT") == 0) return EnergyTransferModeEnumType_AC_BPT;
        if (strcmp(string, "AC_BPT_DER") == 0) return EnergyTransferModeEnumType_AC_BPT_DER;
        if (strcmp(string, "AC_DER") == 0) return EnergyTransferModeEnumType_AC_DER;
        if (strcmp(string, "DC_BPT") == 0) return EnergyTransferModeEnumType_DC_BPT;
        if (strcmp(string, "DC_ACDP") == 0) return EnergyTransferModeEnumType_DC_ACDP;
        if (strcmp(string, "DC_ACDP_BPT") == 0) return EnergyTransferModeEnumType_DC_ACDP_BPT;
        if (strcmp(string, "WPT") == 0) return EnergyTransferModeEnumType_WPT;
    }
    return 0;
}

const char* EnergyTransferModeEnumType_toString(int type)
{
    switch(type) {
        case EnergyTransferModeEnumType_AC_single_phase: return "AC_single_phase";
        case EnergyTransferModeEnumType_AC_two_phase: return "AC_two_phase";
        case EnergyTransferModeEnumType_AC_three_phase: return "AC_three_phase";
        case EnergyTransferModeEnumType_DC: return "DC";
        case EnergyTransferModeEnumType_AC_BPT: return "AC_BPT";
        case EnergyTransferModeEnumType_AC_BPT_DER: return "AC_BPT_DER";
        case EnergyTransferModeEnumType_AC_DER: return "AC_DER";
        case EnergyTransferModeEnumType_DC_BPT: return "DC_BPT";
        case EnergyTransferModeEnumType_DC_ACDP: return "DC_ACDP";
        case EnergyTransferModeEnumType_DC_ACDP_BPT: return "DC_ACDP_BPT";
        case EnergyTransferModeEnumType_WPT: return "WPT";
    }
    return NULL;
}

// 3.38
int EventNotificationEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "HardWiredNotification") == 0) return EventNotificationEnumType_HardWiredNotification;
        if (strcmp(string, "HardWiredMonitor") == 0) return EventNotificationEnumType_HardWiredMonitor;
        if (strcmp(string, "PreconfiguredMonitor") == 0) return EventNotificationEnumType_PreconfiguredMonitor;
        if (strcmp(string, "CustomMonitor") == 0) return EventNotificationEnumType_CustomMonitor;
    }
    return 0;
}

const char* EventNotificationEnumType_toString(int type)
{
    switch(type) {
        case EventNotificationEnumType_HardWiredNotification: return "HardWiredNotification";
        case EventNotificationEnumType_HardWiredMonitor: return "HardWiredMonitor";
        case EventNotificationEnumType_PreconfiguredMonitor: return "PreconfiguredMonitor";
        case EventNotificationEnumType_CustomMonitor: return "CustomMonitor";
    }
    return NULL;
}

//3.39
int EventTriggerEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Alerting") == 0) return EventTriggerEnumType_Alerting;
        if (strcmp(string, "Delta") == 0) return EventTriggerEnumType_Delta;
        if (strcmp(string, "Periodic") == 0) return EventTriggerEnumType_Periodic;
    }
    return 0;
}

const char* EventTriggerEnumType_toString(int type)
{
    switch(type) {
        case EventTriggerEnumType_Alerting: return "Alerting";
        case EventTriggerEnumType_Delta: return "Delta";
        case EventTriggerEnumType_Periodic: return "Periodic";
    }
    return NULL;
}

// 3.40
int EvseKindEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "AC") == 0) return EvseKindEnumType_AC;
        if (strcmp(string, "DC") == 0) return EvseKindEnumType_DC;
    }
    return 0;
}

const char* EvseKindEnumType_toString(int type)
{
    switch(type) {
        case EvseKindEnumType_AC: return "AC";
        case EvseKindEnumType_DC: return "DC";
    }
    return NULL;
}

//3.41
int FirmwareStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Downloaded") == 0) return FirmwareStatusEnumType_Downloaded;
        if (strcmp(string, "DownloadFailed") == 0) return FirmwareStatusEnumType_DownloadFailed;
        if (strcmp(string, "Downloading") == 0) return FirmwareStatusEnumType_Downloading;
        if (strcmp(string, "DownloadScheduled") == 0) return FirmwareStatusEnumType_DownloadScheduled;
        if (strcmp(string, "DownloadPaused") == 0) return FirmwareStatusEnumType_DownloadPaused;
        if (strcmp(string, "Idle") == 0) return FirmwareStatusEnumType_Idle;
        if (strcmp(string, "InstallationFailed") == 0) return FirmwareStatusEnumType_InstallationFailed;
        if (strcmp(string, "Installing") == 0) return FirmwareStatusEnumType_Installing;
        if (strcmp(string, "Installed") == 0) return FirmwareStatusEnumType_Installed;
        if (strcmp(string, "InstallRebooting") == 0) return FirmwareStatusEnumType_InstallRebooting;
        if (strcmp(string, "InstallScheduled") == 0) return FirmwareStatusEnumType_InstallScheduled;
        if (strcmp(string, "InstallVerificationFailed") == 0) return FirmwareStatusEnumType_InstallVerificationFailed;
        if (strcmp(string, "InvalidSignature") == 0) return FirmwareStatusEnumType_InvalidSignature;
        if (strcmp(string, "SignatureVerified") == 0) return FirmwareStatusEnumType_SignatureVerified;
    }
    return 0;
}

const char* FirmwareStatusEnumType_toString(int type)
{
    switch(type) {
        case FirmwareStatusEnumType_Downloaded: return "Downloaded";
        case FirmwareStatusEnumType_DownloadFailed: return "DownloadFailed";
        case FirmwareStatusEnumType_Downloading: return "Downloading";
        case FirmwareStatusEnumType_DownloadScheduled: return "DownloadScheduled";
        case FirmwareStatusEnumType_DownloadPaused: return "DownloadPaused";
        case FirmwareStatusEnumType_Idle: return "Idle";
        case FirmwareStatusEnumType_InstallationFailed: return "InstallationFailed";
        case FirmwareStatusEnumType_Installing: return "Installing";
        case FirmwareStatusEnumType_Installed: return "Installed";
        case FirmwareStatusEnumType_InstallRebooting: return "InstallRebooting";
        case FirmwareStatusEnumType_InstallScheduled: return "InstallScheduled";
        case FirmwareStatusEnumType_InstallVerificationFailed: return "InstallVerificationFailed";
        case FirmwareStatusEnumType_InvalidSignature: return "InvalidSignature";
        case FirmwareStatusEnumType_SignatureVerified: return "SignatureVerified";
    }
    return NULL;
}

// 3.42
int GenericDeviceModelStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GenericDeviceModelStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return GenericDeviceModelStatusEnumType_Rejected;
        if (strcmp(string, "NotSupported") == 0) return GenericDeviceModelStatusEnumType_NotSupported;
        if (strcmp(string, "EmptyResultSet") == 0) return GenericDeviceModelStatusEnumType_EmptyResultSet;
    }
    return 0;
}

const char* GenericDeviceModelStatusEnumType_toString(int type)
{
    switch(type) {
        case GenericDeviceModelStatusEnumType_Accepted: return "Accepted";
        case GenericDeviceModelStatusEnumType_Rejected: return "Rejected";
        case GenericDeviceModelStatusEnumType_NotSupported: return "NotSupported";
        case GenericDeviceModelStatusEnumType_EmptyResultSet: return "EmptyResultSet";
    }
    return NULL;
}

// 3.43
int GenericStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GenericStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return GenericStatusEnumType_Rejected;
    }
    return 0;
}

const char* GenericStatusEnumType_toString(int type)
{
    switch(type) {
        case GenericStatusEnumType_Accepted: return "Accepted";
        case GenericStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

// 3.44
int GetCertificateIdUseEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "V2GRootCertificate") == 0) return GetCertificateIdUseEnumType_V2GRootCertificate;
        if (strcmp(string, "MORootCertificate") == 0) return GetCertificateIdUseEnumType_MORootCertificate;
        if (strcmp(string, "CSMSRootCertificate") == 0) return GetCertificateIdUseEnumType_CSMSRootCertificate;
        if (strcmp(string, "V2GCertificateChain") == 0) return GetCertificateIdUseEnumType_V2GCertificateChain;
        if (strcmp(string, "ManufacturerRootCertificate") == 0) return GetCertificateIdUseEnumType_ManufacturerRootCertificate;
        if (strcmp(string, "OEMRootCertificate") == 0) return GetCertificateIdUseEnumType_OEMRootCertificate;
    }
    return 0;
}

const char* GetCertificateIdUseEnumType_toString(int type)
{
    switch(type) {
        case GetCertificateIdUseEnumType_V2GRootCertificate: return "V2GRootCertificate";
        case GetCertificateIdUseEnumType_MORootCertificate: return "MORootCertificate";
        case GetCertificateIdUseEnumType_CSMSRootCertificate: return "CSMSRootCertificate";
        case GetCertificateIdUseEnumType_V2GCertificateChain: return "V2GCertificateChain";
        case GetCertificateIdUseEnumType_ManufacturerRootCertificate: return "ManufacturerRootCertificate";
        case GetCertificateIdUseEnumType_OEMRootCertificate: return "OEMRootCertificate";
    }
    return NULL;
}

//3.45
int GetCertificateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GetCertificateStatusEnumType_Accepted;
        if (strcmp(string, "Failed") == 0) return GetCertificateStatusEnumType_Failed;
    }
    return 0;
}

const char* GetCertificateStatusEnumType_toString(int type)
{
    switch(type) {
        case GetCertificateStatusEnumType_Accepted: return "Accepted";
        case GetCertificateStatusEnumType_Failed: return "Failed";
    }
    return NULL;
}

// 3.46
int GetChargingProfileStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GetChargingProfileStatusEnumType_Accepted;
        if (strcmp(string, "NoProfiles") == 0) return GetChargingProfileStatusEnumType_NoProfiles;
    }
    return 0;
}

const char* GetChargingProfileStatusEnumType_toString(int type)
{
    switch(type) {
        case GetChargingProfileStatusEnumType_Accepted: return "Accepted";
        case GetChargingProfileStatusEnumType_NoProfiles: return "NoProfiles";
    }
    return NULL;
}

// 3.47
int GetDisplayMessagesStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GetDisplayMessagesStatusEnumType_Accepted;
        if (strcmp(string, "Unknown") == 0) return GetDisplayMessagesStatusEnumType_Unknown;
    }
    return 0;
}

const char* GetDisplayMessagesStatusEnumType_toString(int type)
{
    switch(type) {
        case GetDisplayMessagesStatusEnumType_Accepted: return "Accepted";
        case GetDisplayMessagesStatusEnumType_Unknown: return "Unknown";
    }
    return NULL;
}

// 3.48
int GetInstalledCertificateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GetInstalledCertificateStatusEnumType_Accepted;
        if (strcmp(string, "NotFound") == 0) return GetInstalledCertificateStatusEnumType_NotFound;
    }
    return 0;
}

const char* GetInstalledCertificateStatusEnumType_toString(int type)
{
    switch(type) {
        case GetInstalledCertificateStatusEnumType_Accepted: return "Accepted";
        case GetInstalledCertificateStatusEnumType_NotFound: return "NotFound";
    }
    return NULL;
}

//3.49
int GetVariableStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return GetVariableStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return GetVariableStatusEnumType_Rejected;
        if (strcmp(string, "UnknownComponent") == 0) return GetVariableStatusEnumType_UnknownComponent;
        if (strcmp(string, "UnknownVariable") == 0) return GetVariableStatusEnumType_UnknownVariable;
        if (strcmp(string, "NotSupportedAttributeType") == 0) return GetVariableStatusEnumType_NotSupportedAttributeType;
    }
    return 0;
}

const char* GetVariableStatusEnumType_toString(int type)
{
    switch(type) {
        case GetVariableStatusEnumType_Accepted: return "Accepted";
        case GetVariableStatusEnumType_Rejected: return "Rejected";
        case GetVariableStatusEnumType_UnknownComponent: return "UnknownComponent";
        case GetVariableStatusEnumType_UnknownVariable: return "UnknownVariable";
        case GetVariableStatusEnumType_NotSupportedAttributeType: return "NotSupportedAttributeType";
    }
    return NULL;
}

// 3.50 
int GridEventFaultEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "CurrentImbalance") == 0) return GridEventFaultEnumType_CurrentImbalance;
        if (strcmp(string, "LocalEmergency") == 0) return GridEventFaultEnumType_LocalEmergency;
        if (strcmp(string, "LowInputPower") == 0) return GridEventFaultEnumType_LowInputPower;
        if (strcmp(string, "OverCurrent") == 0) return GridEventFaultEnumType_OverCurrent;
        if (strcmp(string, "OverFrequency") == 0) return GridEventFaultEnumType_OverFrequency;
        if (strcmp(string, "OverVoltage") == 0) return GridEventFaultEnumType_OverVoltage;
        if (strcmp(string, "PhaseRotation") == 0) return GridEventFaultEnumType_PhaseRotation;
        if (strcmp(string, "RemoteEmergency") == 0) return GridEventFaultEnumType_RemoteEmergency;
        if (strcmp(string, "UnderFrequency") == 0) return GridEventFaultEnumType_UnderFrequency;
        if (strcmp(string, "UnderVoltage") == 0) return GridEventFaultEnumType_UnderVoltage;
        if (strcmp(string, "VoltageImbalance") == 0) return GridEventFaultEnumType_VoltageImbalance;
    }
    return 0;
}

const char* GridEventFaultEnumType_toString(int type)
{
    switch(type) {
        case GridEventFaultEnumType_CurrentImbalance: return "CurrentImbalance";
        case GridEventFaultEnumType_LocalEmergency: return "LocalEmergency";
        case GridEventFaultEnumType_LowInputPower: return "LowInputPower";
        case GridEventFaultEnumType_OverCurrent: return "OverCurrent";
        case GridEventFaultEnumType_OverFrequency: return "OverFrequency";
        case GridEventFaultEnumType_OverVoltage: return "OverVoltage";
        case GridEventFaultEnumType_PhaseRotation: return "PhaseRotation";
        case GridEventFaultEnumType_RemoteEmergency: return "RemoteEmergency";
        case GridEventFaultEnumType_UnderFrequency: return "UnderFrequency";
        case GridEventFaultEnumType_UnderVoltage: return "UnderVoltage";
        case GridEventFaultEnumType_VoltageImbalance: return "VoltageImbalance";
    }
    return NULL;
}

// 3.51
int HashAlgorithmEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "SHA256") == 0) return HashAlgorithmEnumType_SHA256;
        if (strcmp(string, "SHA384") == 0) return HashAlgorithmEnumType_SHA384;
        if (strcmp(string, "SHA512") == 0) return HashAlgorithmEnumType_SHA512;
    }
    return 0;
}

const char* HashAlgorithmEnumType_toString(int type)
{
    switch(type) {
        case HashAlgorithmEnumType_SHA256: return "SHA256";
        case HashAlgorithmEnumType_SHA384: return "SHA384";
        case HashAlgorithmEnumType_SHA512: return "SHA512";
    }
    return NULL;
}

// 3.52
int InstallCertificateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return InstallCertificateStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return InstallCertificateStatusEnumType_Rejected;
        if (strcmp(string, "Failed") == 0) return InstallCertificateStatusEnumType_Failed;
    }
    return 0;
}

const char* InstallCertificateStatusEnumType_toString(int type)
{
    switch(type) {
        case InstallCertificateStatusEnumType_Accepted: return "Accepted";
        case InstallCertificateStatusEnumType_Rejected: return "Rejected";
        case InstallCertificateStatusEnumType_Failed: return "Failed";
    }
    return NULL;
}

// 3.53
int InstallCertificateUseEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "V2GRootCertificate") == 0) return InstallCertificateUseEnumType_V2GRootCertificate;
        if (strcmp(string, "MORootCertificate") == 0) return InstallCertificateUseEnumType_MORootCertificate;
        if (strcmp(string, "ManufacturerRootCertificate") == 0) return InstallCertificateUseEnumType_ManufacturerRootCertificate;
        if (strcmp(string, "CSMSRootCertificate") == 0) return InstallCertificateUseEnumType_CSMSRootCertificate;
        if (strcmp(string, "OEMRootCertificate") == 0) return InstallCertificateUseEnumType_OEMRootCertificate;
    }
    return 0;
}

const char* InstallCertificateUseEnumType_toString(int type)
{
    switch(type) {
        case InstallCertificateUseEnumType_V2GRootCertificate: return "V2GRootCertificate";
        case InstallCertificateUseEnumType_MORootCertificate: return "MORootCertificate";
        case InstallCertificateUseEnumType_ManufacturerRootCertificate: return "ManufacturerRootCertificate";
        case InstallCertificateUseEnumType_CSMSRootCertificate: return "CSMSRootCertificate";
        case InstallCertificateUseEnumType_OEMRootCertificate: return "OEMRootCertificate";
    }
    return NULL;
}

// 3.54 
int IslandingDetectionEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "NoAntiIslandingSupport") == 0) return IslandingDetectionEnumType_NoAntiIslandingSupport;
        if (strcmp(string, "RoCoF") == 0) return IslandingDetectionEnumType_RoCoF;
        if (strcmp(string, "UVP_OVP") == 0) return IslandingDetectionEnumType_UVP_OVP;
        if (strcmp(string, "UFP_OFP") == 0) return IslandingDetectionEnumType_UFP_OFP;
        if (strcmp(string, "VoltageVectorShift") == 0) return IslandingDetectionEnumType_VoltageVectorShift;
        if (strcmp(string, "ZeroCrossingDetection") == 0) return IslandingDetectionEnumType_ZeroCrossingDetection;
        if (strcmp(string, "OtherPassive") == 0) return IslandingDetectionEnumType_OtherPassive;
        if (strcmp(string, "ImpedanceMeasurement") == 0) return IslandingDetectionEnumType_ImpedanceMeasurement;
        if (strcmp(string, "ImpedanceAtFrequency") == 0) return IslandingDetectionEnumType_ImpedanceAtFrequency;
        if (strcmp(string, "SlipModeFrequencyShift") == 0) return IslandingDetectionEnumType_SlipModeFrequencyShift;
        if (strcmp(string, "SandiaFrequencyShift") == 0) return IslandingDetectionEnumType_SandiaFrequencyShift;
        if (strcmp(string, "SandiaVoltageShift") == 0) return IslandingDetectionEnumType_SandiaVoltageShift;
        if (strcmp(string, "FrequencyJump") == 0) return IslandingDetectionEnumType_FrequencyJump;
        if (strcmp(string, "RCLQFactor") == 0) return IslandingDetectionEnumType_RCLQFactor;
        if (strcmp(string, "OtherActive") == 0) return IslandingDetectionEnumType_OtherActive;
    }
    return 0;
}

const char* IslandingDetectionEnumType_toString(int type)
{
    switch(type) {
        case IslandingDetectionEnumType_NoAntiIslandingSupport: return "NoAntiIslandingSupport";
        case IslandingDetectionEnumType_RoCoF: return "RoCoF";
        case IslandingDetectionEnumType_UVP_OVP: return "UVP_OVP";
        case IslandingDetectionEnumType_UFP_OFP: return "UFP_OFP";
        case IslandingDetectionEnumType_VoltageVectorShift: return "VoltageVectorShift";
        case IslandingDetectionEnumType_ZeroCrossingDetection: return "ZeroCrossingDetection";
        case IslandingDetectionEnumType_OtherPassive: return "OtherPassive";
        case IslandingDetectionEnumType_ImpedanceMeasurement: return "ImpedanceMeasurement";
        case IslandingDetectionEnumType_ImpedanceAtFrequency: return "ImpedanceAtFrequency";
        case IslandingDetectionEnumType_SlipModeFrequencyShift: return "SlipModeFrequencyShift";
        case IslandingDetectionEnumType_SandiaFrequencyShift: return "SandiaFrequencyShift";
        case IslandingDetectionEnumType_SandiaVoltageShift: return "SandiaVoltageShift";
        case IslandingDetectionEnumType_FrequencyJump: return "FrequencyJump";
        case IslandingDetectionEnumType_RCLQFactor: return "RCLQFactor";
        case IslandingDetectionEnumType_OtherActive: return "OtherActive";
    }
    return NULL;
}

// 3.55
int Iso15118EVCertificateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return Iso15118EVCertificateStatusEnumType_Accepted;
        if (strcmp(string, "Failed") == 0) return Iso15118EVCertificateStatusEnumType_Failed;
    }
    return 0;
}

const char* Iso15118EVCertificateStatusEnumType_toString(int type)
{
    switch(type) {
        case Iso15118EVCertificateStatusEnumType_Accepted: return "Accepted";
        case Iso15118EVCertificateStatusEnumType_Failed: return "Failed";
    }
    return NULL;
}

// 3.56 
int LocationEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Body") == 0) return LocationEnumType_Body;
        if (strcmp(string, "Cable") == 0) return LocationEnumType_Cable;
        if (strcmp(string, "EV") == 0) return LocationEnumType_EV;
        if (strcmp(string, "Inlet") == 0) return LocationEnumType_Inlet;
        if (strcmp(string, "Outlet") == 0) return LocationEnumType_Outlet;
        if (strcmp(string, "Upstream") == 0) return LocationEnumType_Upstream;
    }
    return 0;
}

const char* LocationEnumType_toString(int type)
{
    switch(type) {
        case LocationEnumType_Body: return "Body";
        case LocationEnumType_Cable: return "Cable";
        case LocationEnumType_EV: return "EV";
        case LocationEnumType_Inlet: return "Inlet";
        case LocationEnumType_Outlet: return "Outlet";
        case LocationEnumType_Upstream: return "Upstream";
    }
    return NULL;
}

// 3.57 
int LogEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "DiagnosticsLog") == 0) return LogEnumType_DiagnosticsLog;
        if (strcmp(string, "SecurityLog") == 0) return LogEnumType_SecurityLog;
        if (strcmp(string, "DataCollectorLog") == 0) return LogEnumType_DataCollectorLog;
    }
    return 0;
}

const char* LogEnumType_toString(int type)
{
    switch(type) {
        case LogEnumType_DiagnosticsLog: return "DiagnosticsLog";
        case LogEnumType_SecurityLog: return "SecurityLog";
        case LogEnumType_DataCollectorLog: return "DataCollectorLog";
    }
    return NULL;
}

// 3.58 
int LogStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return LogStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return LogStatusEnumType_Rejected;
        if (strcmp(string, "AcceptedCanceled") == 0) return LogStatusEnumType_AcceptedCanceled;
    }
    return 0;
}

const char* LogStatusEnumType_toString(int type)
{
    switch(type) {
        case LogStatusEnumType_Accepted: return "Accepted";
        case LogStatusEnumType_Rejected: return "Rejected";
        case LogStatusEnumType_AcceptedCanceled: return "AcceptedCanceled";
    }
    return NULL;
}

// 3.59
int MeasurandEnumType_fromString(const char *string)
{
    if (string) {
        // 基础测量量相关
        if (strcmp(string, "Current.Export") == 0) return MeasurandEnumType_Current_Export;
        if (strcmp(string, "Current.Export.Offered") == 0) return MeasurandEnumType_Current_Export_Offered;
        if (strcmp(string, "Current.Export.Minimum") == 0) return MeasurandEnumType_Current_Export_Minimum;
        if (strcmp(string, "Current.Import") == 0) return MeasurandEnumType_Current_Import;
        if (strcmp(string, "Current.Import.Offered") == 0) return MeasurandEnumType_Current_Import_Offered;
        if (strcmp(string, "Current.Import.Minimum") == 0) return MeasurandEnumType_Current_Import_Minimum;
        if (strcmp(string, "Current.Offered") == 0) return MeasurandEnumType_Current_Offered;
        // 显示相关
        if (strcmp(string, "Display.PresentSOC") == 0) return MeasurandEnumType_Display_PresentSOC;
        if (strcmp(string, "Display.MinimumSOC") == 0) return MeasurandEnumType_Display_MinimumSOC;
        if (strcmp(string, "Display.TargetSOC") == 0) return MeasurandEnumType_Display_TargetSOC;
        if (strcmp(string, "Display.MaximumSOC") == 0) return MeasurandEnumType_Display_MaximumSOC;
        if (strcmp(string, "Display.RemainingTimeToMinimumSOC") == 0) return MeasurandEnumType_Display_RemainingTimeToMinimumSOC;
        if (strcmp(string, "Display.RemainingTimeToTargetSOC") == 0) return MeasurandEnumType_Display_RemainingTimeToTargetSOC;
        if (strcmp(string, "Display.RemainingTimeToMaximumSOC") == 0) return MeasurandEnumType_Display_RemainingTimeToMaximumSOC;
        if (strcmp(string, "Display.ChargingComplete") == 0) return MeasurandEnumType_Display_ChargingComplete;
        if (strcmp(string, "Display.BatteryEnergyCapacity") == 0) return MeasurandEnumType_Display_BatteryEnergyCapacity;
        if (strcmp(string, "Display.InletHot") == 0) return MeasurandEnumType_Display_InletHot;
        // 能量相关（Active）
        if (strcmp(string, "Energy.Active.Export.Interval") == 0) return MeasurandEnumType_Energy_Active_Export_Interval;
        if (strcmp(string, "Energy.Active.Export.Register") == 0) return MeasurandEnumType_Energy_Active_Export_Register;
        if (strcmp(string, "Energy.Active.Import.Interval") == 0) return MeasurandEnumType_Energy_Active_Import_Interval;
        if (strcmp(string, "Energy.Active.Import.Register") == 0) return MeasurandEnumType_Energy_Active_Import_Register;
        if (strcmp(string, "Energy.Active.Import.CableLoss") == 0) return MeasurandEnumType_Energy_Active_Import_CableLoss;
        if (strcmp(string, "Energy.Active.Import.LocalGeneration.Register") == 0) return MeasurandEnumType_Energy_Active_Import_LocalGeneration_Register;
        if (strcmp(string, "Energy.Active.Net") == 0) return MeasurandEnumType_Energy_Active_Net;
        if (strcmp(string, "Energy.Active.Setpoint.Interval") == 0) return MeasurandEnumType_Energy_Active_Setpoint_Interval;
        // 能量相关（Apparent）
        if (strcmp(string, "Energy.Apparent.Export") == 0) return MeasurandEnumType_Energy_Apparent_Export;
        if (strcmp(string, "Energy.Apparent.Import") == 0) return MeasurandEnumType_Energy_Apparent_Import;
        if (strcmp(string, "Energy.Apparent.Net") == 0) return MeasurandEnumType_Energy_Apparent_Net;
        // 能量相关（Reactive）
        if (strcmp(string, "Energy.Reactive.Export.Interval") == 0) return MeasurandEnumType_Energy_Reactive_Export_Interval;
        if (strcmp(string, "Energy.Reactive.Export.Register") == 0) return MeasurandEnumType_Energy_Reactive_Export_Register;
        if (strcmp(string, "Energy.Reactive.Import.Interval") == 0) return MeasurandEnumType_Energy_Reactive_Import_Interval;
        if (strcmp(string, "Energy.Reactive.Import.Register") == 0) return MeasurandEnumType_Energy_Reactive_Import_Register;
        if (strcmp(string, "Energy.Reactive.Net") == 0) return MeasurandEnumType_Energy_Reactive_Net;
        // 能量请求相关
        if (strcmp(string, "EnergyRequest.Target") == 0) return MeasurandEnumType_EnergyRequest_Target;
        if (strcmp(string, "EnergyRequest.Minimum") == 0) return MeasurandEnumType_EnergyRequest_Minimum;
        if (strcmp(string, "EnergyRequest.Maximum") == 0) return MeasurandEnumType_EnergyRequest_Maximum;
        if (strcmp(string, "EnergyRequest.Minimum.V2X") == 0) return MeasurandEnumType_EnergyRequest_Minimum_V2X;
        if (strcmp(string, "EnergyRequest.Maximum.V2X") == 0) return MeasurandEnumType_EnergyRequest_Maximum_V2X;
        if (strcmp(string, "EnergyRequest.Bulk") == 0) return MeasurandEnumType_EnergyRequest_Bulk;
        // 频率、功率相关
        if (strcmp(string, "Frequency") == 0) return MeasurandEnumType_Frequency;
        if (strcmp(string, "Power.Active.Export") == 0) return MeasurandEnumType_Power_Active_Export;
        if (strcmp(string, "Power.Active.Import") == 0) return MeasurandEnumType_Power_Active_Import;
        if (strcmp(string, "Power.Active.Setpoint") == 0) return MeasurandEnumType_Power_Active_Setpoint;
        if (strcmp(string, "Power.Export.Minimum") == 0) return MeasurandEnumType_Power_Export_Minimum;
        if (strcmp(string, "Power.Export.Offered") == 0) return MeasurandEnumType_Power_Export_Offered;
        if (strcmp(string, "Power.Factor") == 0) return MeasurandEnumType_Power_Factor;
        if (strcmp(string, "Power.Import.Offered") == 0) return MeasurandEnumType_Power_Import_Offered;
        if (strcmp(string, "Power.Import.Minimum") == 0) return MeasurandEnumType_Power_Import_Minimum;
        if (strcmp(string, "Power.Offered") == 0) return MeasurandEnumType_Power_Offered;
        if (strcmp(string, "Power.Reactive.Export") == 0) return MeasurandEnumType_Power_Reactive_Export;
        if (strcmp(string, "Power.Reactive.Import") == 0) return MeasurandEnumType_Power_Reactive_Import;
        // 其他
        if (strcmp(string, "SoC") == 0) return MeasurandEnumType_SoC;
        if (strcmp(string, "Voltage") == 0) return MeasurandEnumType_Voltage;
        if (strcmp(string, "Voltage.Minimum") == 0) return MeasurandEnumType_Voltage_Minimum;
        if (strcmp(string, "Voltage.Maximum") == 0) return MeasurandEnumType_Voltage_Maximum;
    }
    return 0;
}

const char* MeasurandEnumType_toString(int type)
{
    switch(type) {
        // 基础测量量相关
        case MeasurandEnumType_Current_Export: return "Current.Export";
        case MeasurandEnumType_Current_Export_Offered: return "Current.Export.Offered";
        case MeasurandEnumType_Current_Export_Minimum: return "Current.Export.Minimum";
        case MeasurandEnumType_Current_Import: return "Current.Import";
        case MeasurandEnumType_Current_Import_Offered: return "Current.Import.Offered";
        case MeasurandEnumType_Current_Import_Minimum: return "Current.Import.Minimum";
        case MeasurandEnumType_Current_Offered: return "Current.Offered";
        // 显示相关
        case MeasurandEnumType_Display_PresentSOC: return "Display.PresentSOC";
        case MeasurandEnumType_Display_MinimumSOC: return "Display.MinimumSOC";
        case MeasurandEnumType_Display_TargetSOC: return "Display.TargetSOC";
        case MeasurandEnumType_Display_MaximumSOC: return "Display.MaximumSOC";
        case MeasurandEnumType_Display_RemainingTimeToMinimumSOC: return "Display.RemainingTimeToMinimumSOC";
        case MeasurandEnumType_Display_RemainingTimeToTargetSOC: return "Display.RemainingTimeToTargetSOC";
        case MeasurandEnumType_Display_RemainingTimeToMaximumSOC: return "Display.RemainingTimeToMaximumSOC";
        case MeasurandEnumType_Display_ChargingComplete: return "Display.ChargingComplete";
        case MeasurandEnumType_Display_BatteryEnergyCapacity: return "Display.BatteryEnergyCapacity";
        case MeasurandEnumType_Display_InletHot: return "Display.InletHot";
        // 能量相关（Active）
        case MeasurandEnumType_Energy_Active_Export_Interval: return "Energy.Active.Export.Interval";
        case MeasurandEnumType_Energy_Active_Export_Register: return "Energy.Active.Export.Register";
        case MeasurandEnumType_Energy_Active_Import_Interval: return "Energy.Active.Import.Interval";
        case MeasurandEnumType_Energy_Active_Import_Register: return "Energy.Active.Import.Register";
        case MeasurandEnumType_Energy_Active_Import_CableLoss: return "Energy.Active.Import.CableLoss";
        case MeasurandEnumType_Energy_Active_Import_LocalGeneration_Register: return "Energy.Active.Import.LocalGeneration.Register";
        case MeasurandEnumType_Energy_Active_Net: return "Energy.Active.Net";
        case MeasurandEnumType_Energy_Active_Setpoint_Interval: return "Energy.Active.Setpoint.Interval";
        // 能量相关（Apparent）
        case MeasurandEnumType_Energy_Apparent_Export: return "Energy.Apparent.Export";
        case MeasurandEnumType_Energy_Apparent_Import: return "Energy.Apparent.Import";
        case MeasurandEnumType_Energy_Apparent_Net: return "Energy.Apparent.Net";
        // 能量相关（Reactive）
        case MeasurandEnumType_Energy_Reactive_Export_Interval: return "Energy.Reactive.Export.Interval";
        case MeasurandEnumType_Energy_Reactive_Export_Register: return "Energy.Reactive.Export.Register";
        case MeasurandEnumType_Energy_Reactive_Import_Interval: return "Energy.Reactive.Import.Interval";
        case MeasurandEnumType_Energy_Reactive_Import_Register: return "Energy.Reactive.Import.Register";
        case MeasurandEnumType_Energy_Reactive_Net: return "Energy.Reactive.Net";
        // 能量请求相关
        case MeasurandEnumType_EnergyRequest_Target: return "EnergyRequest.Target";
        case MeasurandEnumType_EnergyRequest_Minimum: return "EnergyRequest.Minimum";
        case MeasurandEnumType_EnergyRequest_Maximum: return "EnergyRequest.Maximum";
        case MeasurandEnumType_EnergyRequest_Minimum_V2X: return "EnergyRequest.Minimum.V2X";
        case MeasurandEnumType_EnergyRequest_Maximum_V2X: return "EnergyRequest.Maximum.V2X";
        case MeasurandEnumType_EnergyRequest_Bulk: return "EnergyRequest.Bulk";
        // 频率、功率相关
        case MeasurandEnumType_Frequency: return "Frequency";
        case MeasurandEnumType_Power_Active_Export: return "Power.Active.Export";
        case MeasurandEnumType_Power_Active_Import: return "Power.Active.Import";
        case MeasurandEnumType_Power_Active_Setpoint: return "Power.Active.Setpoint";
        case MeasurandEnumType_Power_Export_Minimum: return "Power.Export.Minimum";
        case MeasurandEnumType_Power_Export_Offered: return "Power.Export.Offered";
        case MeasurandEnumType_Power_Factor: return "Power.Factor";
        case MeasurandEnumType_Power_Import_Offered: return "Power.Import.Offered";
        case MeasurandEnumType_Power_Import_Minimum: return "Power.Import.Minimum";
        case MeasurandEnumType_Power_Offered: return "Power.Offered";
        case MeasurandEnumType_Power_Reactive_Export: return "Power.Reactive.Export";
        case MeasurandEnumType_Power_Reactive_Import: return "Power.Reactive.Import";
        // 其他
        case MeasurandEnumType_SoC: return "SoC";
        case MeasurandEnumType_Voltage: return "Voltage";
        case MeasurandEnumType_Voltage_Minimum: return "Voltage.Minimum";
        case MeasurandEnumType_Voltage_Maximum: return "Voltage.Maximum";
    }
    return NULL;
}

// 3.60 
int MessageFormatEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ASCII") == 0) return MessageFormatEnumType_ASCII;
        if (strcmp(string, "HTML") == 0) return MessageFormatEnumType_HTML;
        if (strcmp(string, "URI") == 0) return MessageFormatEnumType_URI;
        if (strcmp(string, "UTF8") == 0) return MessageFormatEnumType_UTF8;
        if (strcmp(string, "QRCODE") == 0) return MessageFormatEnumType_QRCODE;
    }
    return 0;
}

const char* MessageFormatEnumType_toString(int type)
{
    switch(type) {
        case MessageFormatEnumType_ASCII: return "ASCII";
        case MessageFormatEnumType_HTML: return "HTML";
        case MessageFormatEnumType_URI: return "URI";
        case MessageFormatEnumType_UTF8: return "UTF8";
        case MessageFormatEnumType_QRCODE: return "QRCODE";
    }
    return NULL;
}

// 3.61 
int MessagePriorityEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "AlwaysFront") == 0) return MessagePriorityEnumType_AlwaysFront;
        if (strcmp(string, "InFront") == 0) return MessagePriorityEnumType_InFront;
        if (strcmp(string, "NormalCycle") == 0) return MessagePriorityEnumType_NormalCycle;
    }
    return 0;
}

const char* MessagePriorityEnumType_toString(int type)
{
    switch(type) {
        case MessagePriorityEnumType_AlwaysFront: return "AlwaysFront";
        case MessagePriorityEnumType_InFront: return "InFront";
        case MessagePriorityEnumType_NormalCycle: return "NormalCycle";
    }
    return NULL;
}

// 3.62
int MessageStateEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Charging") == 0) return MessageStateEnumType_Charging;
        if (strcmp(string, "Faulted") == 0) return MessageStateEnumType_Faulted;
        if (strcmp(string, "Idle") == 0) return MessageStateEnumType_Idle;
        if (strcmp(string, "Unavailable") == 0) return MessageStateEnumType_Unavailable;
        if (strcmp(string, "Suspended") == 0) return MessageStateEnumType_Suspended;
        if (strcmp(string, "Discharging") == 0) return MessageStateEnumType_Discharging;
    }
    return 0;
}

const char* MessageStateEnumType_toString(int type)
{
    switch(type) {
        case MessageStateEnumType_Charging: return "Charging";
        case MessageStateEnumType_Faulted: return "Faulted";
        case MessageStateEnumType_Idle: return "Idle";
        case MessageStateEnumType_Unavailable: return "Unavailable";
        case MessageStateEnumType_Suspended: return "Suspended";
        case MessageStateEnumType_Discharging: return "Discharging";
    }
    return NULL;
}

// 3.63
int MessageTriggerEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "BootNotification") == 0) return MessageTriggerEnumType_BootNotification;
        if (strcmp(string, "LogStatusNotification") == 0) return MessageTriggerEnumType_LogStatusNotification;
        if (strcmp(string, "FirmwareStatusNotification") == 0) return MessageTriggerEnumType_FirmwareStatusNotification;
        if (strcmp(string, "Heartbeat") == 0) return MessageTriggerEnumType_Heartbeat;
        if (strcmp(string, "MeterValues") == 0) return MessageTriggerEnumType_MeterValues;
        if (strcmp(string, "SignChargingStationCertificate") == 0) return MessageTriggerEnumType_SignChargingStationCertificate;
        if (strcmp(string, "SignV2GCertificate") == 0) return MessageTriggerEnumType_SignV2GCertificate;
        if (strcmp(string, "SignV2G20Certificate") == 0) return MessageTriggerEnumType_SignV2G20Certificate;
        if (strcmp(string, "StatusNotification") == 0) return MessageTriggerEnumType_StatusNotification;
        if (strcmp(string, "TransactionEvent") == 0) return MessageTriggerEnumType_TransactionEvent;
        if (strcmp(string, "SignCombinedCertificate") == 0) return MessageTriggerEnumType_SignCombinedCertificate;
        if (strcmp(string, "PublishFirmwareStatusNotification") == 0) return MessageTriggerEnumType_PublishFirmwareStatusNotification;
        if (strcmp(string, "CustomTrigger") == 0) return MessageTriggerEnumType_CustomTrigger;
    }
    return 0;
}

const char* MessageTriggerEnumType_toString(int type)
{
    switch(type) {
        case MessageTriggerEnumType_BootNotification: return "BootNotification";
        case MessageTriggerEnumType_LogStatusNotification: return "LogStatusNotification";
        case MessageTriggerEnumType_FirmwareStatusNotification: return "FirmwareStatusNotification";
        case MessageTriggerEnumType_Heartbeat: return "Heartbeat";
        case MessageTriggerEnumType_MeterValues: return "MeterValues";
        case MessageTriggerEnumType_SignChargingStationCertificate: return "SignChargingStationCertificate";
        case MessageTriggerEnumType_SignV2GCertificate: return "SignV2GCertificate";
        case MessageTriggerEnumType_SignV2G20Certificate: return "SignV2G20Certificate";
        case MessageTriggerEnumType_StatusNotification: return "StatusNotification";
        case MessageTriggerEnumType_TransactionEvent: return "TransactionEvent";
        case MessageTriggerEnumType_SignCombinedCertificate: return "SignCombinedCertificate";
        case MessageTriggerEnumType_PublishFirmwareStatusNotification: return "PublishFirmwareStatusNotification";
        case MessageTriggerEnumType_CustomTrigger: return "CustomTrigger";
    }
    return NULL;
}

// 3.64
int MobilityNeedsModeEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "EVCC") == 0) return MobilityNeedsModeEnumType_EVCC;
        if (strcmp(string, "EVCC_SECC") == 0) return MobilityNeedsModeEnumType_EVCC_SECC;
    }
    return 0;
}

const char* MobilityNeedsModeEnumType_toString(int type)
{
    switch(type) {
        case MobilityNeedsModeEnumType_EVCC: return "EVCC";
        case MobilityNeedsModeEnumType_EVCC_SECC: return "EVCC_SECC";
    }
    return NULL;
}

// 3.65
int MonitorEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "UpperThreshold") == 0) return MonitorEnumType_UpperThreshold;
        if (strcmp(string, "LowerThreshold") == 0) return MonitorEnumType_LowerThreshold;
        if (strcmp(string, "Delta") == 0) return MonitorEnumType_Delta;
        if (strcmp(string, "Periodic") == 0) return MonitorEnumType_Periodic;
        if (strcmp(string, "PeriodicClockAligned") == 0) return MonitorEnumType_PeriodicClockAligned;
        if (strcmp(string, "TargetDelta") == 0) return MonitorEnumType_TargetDelta;
        if (strcmp(string, "TargetDeltaRelative") == 0) return MonitorEnumType_TargetDeltaRelative;
    }
    return 0;
}

const char* MonitorEnumType_toString(int type)
{
    switch(type) {
        case MonitorEnumType_UpperThreshold: return "UpperThreshold";
        case MonitorEnumType_LowerThreshold: return "LowerThreshold";
        case MonitorEnumType_Delta: return "Delta";
        case MonitorEnumType_Periodic: return "Periodic";
        case MonitorEnumType_PeriodicClockAligned: return "PeriodicClockAligned";
        case MonitorEnumType_TargetDelta: return "TargetDelta";
        case MonitorEnumType_TargetDeltaRelative: return "TargetDeltaRelative";
    }
    return NULL;
}

// 3.66 
int MonitoringBaseEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "All") == 0) return MonitoringBaseEnumType_All;
        if (strcmp(string, "FactoryDefault") == 0) return MonitoringBaseEnumType_FactoryDefault;
        if (strcmp(string, "HardWiredOnly") == 0) return MonitoringBaseEnumType_HardWiredOnly;
    }
    return 0;
}

const char* MonitoringBaseEnumType_toString(int type)
{
    switch(type) {
        case MonitoringBaseEnumType_All: return "All";
        case MonitoringBaseEnumType_FactoryDefault: return "FactoryDefault";
        case MonitoringBaseEnumType_HardWiredOnly: return "HardWiredOnly";
    }
    return NULL;
}

// 3.67 
int MonitoringCriterionEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ThresholdMonitoring") == 0) return MonitoringCriterionEnumType_ThresholdMonitoring;
        if (strcmp(string, "DeltaMonitoring") == 0) return MonitoringCriterionEnumType_DeltaMonitoring;
        if (strcmp(string, "PeriodicMonitoring") == 0) return MonitoringCriterionEnumType_PeriodicMonitoring;
    }
    return 0;
}

const char* MonitoringCriterionEnumType_toString(int type)
{
    switch(type) {
        case MonitoringCriterionEnumType_ThresholdMonitoring: return "ThresholdMonitoring";
        case MonitoringCriterionEnumType_DeltaMonitoring: return "DeltaMonitoring";
        case MonitoringCriterionEnumType_PeriodicMonitoring: return "PeriodicMonitoring";
    }
    return NULL;
}

// 3.68
int MutabilityEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ReadOnly") == 0) return MutabilityEnumType_ReadOnly;
        if (strcmp(string, "WriteOnly") == 0) return MutabilityEnumType_WriteOnly;
        if (strcmp(string, "ReadWrite") == 0) return MutabilityEnumType_ReadWrite;
    }
    return 0;
}

const char* MutabilityEnumType_toString(int type)
{
    switch(type) {
        case MutabilityEnumType_ReadOnly: return "ReadOnly";
        case MutabilityEnumType_WriteOnly: return "WriteOnly";
        case MutabilityEnumType_ReadWrite: return "ReadWrite";
    }
    return NULL;
}

// 3.69
int NotifyAllowedEnergyTransferStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return NotifyAllowedEnergyTransferStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return NotifyAllowedEnergyTransferStatusEnumType_Rejected;
    }
    return 0;
}

const char* NotifyAllowedEnergyTransferStatusEnumType_toString(int type)
{
    switch(type) {
        case NotifyAllowedEnergyTransferStatusEnumType_Accepted: return "Accepted";
        case NotifyAllowedEnergyTransferStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

// 3.70 
int NotifyEVChargingNeedsStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return NotifyEVChargingNeedsStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return NotifyEVChargingNeedsStatusEnumType_Rejected;
        if (strcmp(string, "Processing") == 0) return NotifyEVChargingNeedsStatusEnumType_Processing;
        if (strcmp(string, "NoChargingProfile") == 0) return NotifyEVChargingNeedsStatusEnumType_NoChargingProfile;
    }
    return 0;
}

const char* NotifyEVChargingNeedsStatusEnumType_toString(int type)
{
    switch(type) {
        case NotifyEVChargingNeedsStatusEnumType_Accepted: return "Accepted";
        case NotifyEVChargingNeedsStatusEnumType_Rejected: return "Rejected";
        case NotifyEVChargingNeedsStatusEnumType_Processing: return "Processing";
        case NotifyEVChargingNeedsStatusEnumType_NoChargingProfile: return "NoChargingProfile";
    }
    return NULL;
}

// 3.71 
int OCPPInterfaceEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Wired0") == 0) return OCPPInterfaceEnumType_Wired0;
        if (strcmp(string, "Wired1") == 0) return OCPPInterfaceEnumType_Wired1;
        if (strcmp(string, "Wired2") == 0) return OCPPInterfaceEnumType_Wired2;
        if (strcmp(string, "Wired3") == 0) return OCPPInterfaceEnumType_Wired3;
        if (strcmp(string, "Wireless0") == 0) return OCPPInterfaceEnumType_Wireless0;
        if (strcmp(string, "Wireless1") == 0) return OCPPInterfaceEnumType_Wireless1;
        if (strcmp(string, "Wireless2") == 0) return OCPPInterfaceEnumType_Wireless2;
        if (strcmp(string, "Wireless3") == 0) return OCPPInterfaceEnumType_Wireless3;
        if (strcmp(string, "Any") == 0) return OCPPInterfaceEnumType_Any;
    }
    return 0;
}

const char* OCPPInterfaceEnumType_toString(int type)
{
    switch(type) {
        case OCPPInterfaceEnumType_Wired0: return "Wired0";
        case OCPPInterfaceEnumType_Wired1: return "Wired1";
        case OCPPInterfaceEnumType_Wired2: return "Wired2";
        case OCPPInterfaceEnumType_Wired3: return "Wired3";
        case OCPPInterfaceEnumType_Wireless0: return "Wireless0";
        case OCPPInterfaceEnumType_Wireless1: return "Wireless1";
        case OCPPInterfaceEnumType_Wireless2: return "Wireless2";
        case OCPPInterfaceEnumType_Wireless3: return "Wireless3";
        case OCPPInterfaceEnumType_Any: return "Any";
    }
    return NULL;
}

// 3.72 
int OCPPTransportEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "SOAP") == 0) return OCPPTransportEnumType_SOAP;
        if (strcmp(string, "JSON") == 0) return OCPPTransportEnumType_JSON;
    }
    return 0;
}

const char* OCPPTransportEnumType_toString(int type)
{
    switch(type) {
        case OCPPTransportEnumType_SOAP: return "SOAP";
        case OCPPTransportEnumType_JSON: return "JSON";
    }
    return NULL;
}

// 3.73 
int OCPPVersionEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "OCPP12") == 0) return OCPPVersionEnumType_OCPP12;
        if (strcmp(string, "OCPP15") == 0) return OCPPVersionEnumType_OCPP15;
        if (strcmp(string, "OCPP16") == 0) return OCPPVersionEnumType_OCPP16;
        if (strcmp(string, "OCPP20") == 0) return OCPPVersionEnumType_OCPP20;
        if (strcmp(string, "OCPP201") == 0) return OCPPVersionEnumType_OCPP201;
        if (strcmp(string, "OCPP21") == 0) return OCPPVersionEnumType_OCPP21;
    }
    return 0;
}

const char* OCPPVersionEnumType_toString(int type)
{
    switch(type) {
        case OCPPVersionEnumType_OCPP12: return "OCPP12";
        case OCPPVersionEnumType_OCPP15: return "OCPP15";
        case OCPPVersionEnumType_OCPP16: return "OCPP16";
        case OCPPVersionEnumType_OCPP20: return "OCPP20";
        case OCPPVersionEnumType_OCPP201: return "OCPP201";
        case OCPPVersionEnumType_OCPP21: return "OCPP21";
    }
    return NULL;
}

// 3.74
int OperationalStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Inoperative") == 0) return OperationalStatusEnumType_Inoperative;
        if (strcmp(string, "Operative") == 0) return OperationalStatusEnumType_Operative;
    }
    return 0;
}

const char* OperationalStatusEnumType_toString(int type)
{
    switch(type) {
        case OperationalStatusEnumType_Inoperative: return "Inoperative";
        case OperationalStatusEnumType_Operative: return "Operative";
    }
    return NULL;
}

// 3.75 
int OperationModeEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Idle") == 0) return OperationModeEnumType_Idle;
        if (strcmp(string, "ChargingOnly") == 0) return OperationModeEnumType_ChargingOnly;
        if (strcmp(string, "CentralSetpoint") == 0) return OperationModeEnumType_CentralSetpoint;
        if (strcmp(string, "ExternalSetpoint") == 0) return OperationModeEnumType_ExternalSetpoint;
        if (strcmp(string, "ExternalLimits") == 0) return OperationModeEnumType_ExternalLimits;
        if (strcmp(string, "CentralFrequency") == 0) return OperationModeEnumType_CentralFrequency;
        if (strcmp(string, "LocalFrequency") == 0) return OperationModeEnumType_LocalFrequency;
        if (strcmp(string, "LocalLoadBalancing") == 0) return OperationModeEnumType_LocalLoadBalancing;
    }
    return 0;
}

const char* OperationModeEnumType_toString(int type)
{
    switch(type) {
        case OperationModeEnumType_Idle: return "Idle";
        case OperationModeEnumType_ChargingOnly: return "ChargingOnly";
        case OperationModeEnumType_CentralSetpoint: return "CentralSetpoint";
        case OperationModeEnumType_ExternalSetpoint: return "ExternalSetpoint";
        case OperationModeEnumType_ExternalLimits: return "ExternalLimits";
        case OperationModeEnumType_CentralFrequency: return "CentralFrequency";
        case OperationModeEnumType_LocalFrequency: return "LocalFrequency";
        case OperationModeEnumType_LocalLoadBalancing: return "LocalLoadBalancing";
    }
    return NULL;
}

// 3.76 
int PaymentStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Settled") == 0) return PaymentStatusEnumType_Settled;
        if (strcmp(string, "Canceled") == 0) return PaymentStatusEnumType_Canceled;
        if (strcmp(string, "Rejected") == 0) return PaymentStatusEnumType_Rejected;
        if (strcmp(string, "Failed") == 0) return PaymentStatusEnumType_Failed;
    }
    return 0;
}

const char* PaymentStatusEnumType_toString(int type)
{
    switch(type) {
        case PaymentStatusEnumType_Settled: return "Settled";
        case PaymentStatusEnumType_Canceled: return "Canceled";
        case PaymentStatusEnumType_Rejected: return "Rejected";
        case PaymentStatusEnumType_Failed: return "Failed";
    }
    return NULL;
}

// 3.77 
int PhaseEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "L1") == 0) return PhaseEnumType_L1;
        if (strcmp(string, "L2") == 0) return PhaseEnumType_L2;
        if (strcmp(string, "L3") == 0) return PhaseEnumType_L3;
        if (strcmp(string, "N") == 0) return PhaseEnumType_N;
        if (strcmp(string, "L1-N") == 0) return PhaseEnumType_L1_N;
        if (strcmp(string, "L2-N") == 0) return PhaseEnumType_L2_N;
        if (strcmp(string, "L3-N") == 0) return PhaseEnumType_L3_N;
        if (strcmp(string, "L1-L2") == 0) return PhaseEnumType_L1_L2;
        if (strcmp(string, "L2-L3") == 0) return PhaseEnumType_L2_L3;
        if (strcmp(string, "L3-L1") == 0) return PhaseEnumType_L3_L1;
    }
    return 0;
}

const char* PhaseEnumType_toString(int type)
{
    switch(type) {
        case PhaseEnumType_L1: return "L1";
        case PhaseEnumType_L2: return "L2";
        case PhaseEnumType_L3: return "L3";
        case PhaseEnumType_N: return "N";
        case PhaseEnumType_L1_N: return "L1-N";
        case PhaseEnumType_L2_N: return "L2-N";
        case PhaseEnumType_L3_N: return "L3-N";
        case PhaseEnumType_L1_L2: return "L1-L2";
        case PhaseEnumType_L2_L3: return "L2-L3";
        case PhaseEnumType_L3_L1: return "L3-L1";
    }
    return NULL;
}

// 3.78 
int PowerDuringCessationEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Active") == 0) return PowerDuringCessationEnumType_Active;
        if (strcmp(string, "Reactive") == 0) return PowerDuringCessationEnumType_Reactive;
    }
    return 0;
}

const char* PowerDuringCessationEnumType_toString(int type)
{
    switch(type) {
        case PowerDuringCessationEnumType_Active: return "Active";
        case PowerDuringCessationEnumType_Reactive: return "Reactive";
    }
    return NULL;
}

// 3.79 
int PreconditioningStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Unknown") == 0) return PreconditioningStatusEnumType_Unknown;
        if (strcmp(string, "Ready") == 0) return PreconditioningStatusEnumType_Ready;
        if (strcmp(string, "NotReady") == 0) return PreconditioningStatusEnumType_NotReady;
        if (strcmp(string, "Preconditioning") == 0) return PreconditioningStatusEnumType_Preconditioning;
    }
    return 0;
}

const char* PreconditioningStatusEnumType_toString(int type)
{
    switch(type) {
        case PreconditioningStatusEnumType_Unknown: return "Unknown";
        case PreconditioningStatusEnumType_Ready: return "Ready";
        case PreconditioningStatusEnumType_NotReady: return "NotReady";
        case PreconditioningStatusEnumType_Preconditioning: return "Preconditioning";
    }
    return NULL;
}

// 3.80 
int PriorityChargingStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return PriorityChargingStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return PriorityChargingStatusEnumType_Rejected;
        if (strcmp(string, "NoProfile") == 0) return PriorityChargingStatusEnumType_NoProfile;
    }
    return 0;
}

const char* PriorityChargingStatusEnumType_toString(int type)
{
    switch(type) {
        case PriorityChargingStatusEnumType_Accepted: return "Accepted";
        case PriorityChargingStatusEnumType_Rejected: return "Rejected";
        case PriorityChargingStatusEnumType_NoProfile: return "NoProfile";
    }
    return NULL;
}

// 3.81 
int PublishFirmwareStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Idle") == 0) return PublishFirmwareStatusEnumType_Idle;
        if (strcmp(string, "DownloadScheduled") == 0) return PublishFirmwareStatusEnumType_DownloadScheduled;
        if (strcmp(string, "Downloading") == 0) return PublishFirmwareStatusEnumType_Downloading;
        if (strcmp(string, "Downloaded") == 0) return PublishFirmwareStatusEnumType_Downloaded;
        if (strcmp(string, "Published") == 0) return PublishFirmwareStatusEnumType_Published;
        if (strcmp(string, "DownloadFailed") == 0) return PublishFirmwareStatusEnumType_DownloadFailed;
        if (strcmp(string, "DownloadPaused") == 0) return PublishFirmwareStatusEnumType_DownloadPaused;
        if (strcmp(string, "InvalidChecksum") == 0) return PublishFirmwareStatusEnumType_InvalidChecksum;
        if (strcmp(string, "ChecksumVerified") == 0) return PublishFirmwareStatusEnumType_ChecksumVerified;
        if (strcmp(string, "PublishFailed") == 0) return PublishFirmwareStatusEnumType_PublishFailed;
    }
    return 0;
}

const char* PublishFirmwareStatusEnumType_toString(int type)
{
    switch(type) {
        case PublishFirmwareStatusEnumType_Idle: return "Idle";
        case PublishFirmwareStatusEnumType_DownloadScheduled: return "DownloadScheduled";
        case PublishFirmwareStatusEnumType_Downloading: return "Downloading";
        case PublishFirmwareStatusEnumType_Downloaded: return "Downloaded";
        case PublishFirmwareStatusEnumType_Published: return "Published";
        case PublishFirmwareStatusEnumType_DownloadFailed: return "DownloadFailed";
        case PublishFirmwareStatusEnumType_DownloadPaused: return "DownloadPaused";
        case PublishFirmwareStatusEnumType_InvalidChecksum: return "InvalidChecksum";
        case PublishFirmwareStatusEnumType_ChecksumVerified: return "ChecksumVerified";
        case PublishFirmwareStatusEnumType_PublishFailed: return "PublishFailed";
    }
    return NULL;
}

// 3.82
int ReadingContextEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Interruption.Begin") == 0) return ReadingContextEnumType_Interruption_Begin;
        if (strcmp(string, "Interruption.End") == 0) return ReadingContextEnumType_Interruption_End;
        if (strcmp(string, "Other") == 0) return ReadingContextEnumType_Other;
        if (strcmp(string, "Sample.Clock") == 0) return ReadingContextEnumType_Sample_Clock;
        if (strcmp(string, "Sample.Periodic") == 0) return ReadingContextEnumType_Sample_Periodic;
        if (strcmp(string, "Transaction.Begin") == 0) return ReadingContextEnumType_Transaction_Begin;
        if (strcmp(string, "Transaction.End") == 0) return ReadingContextEnumType_Transaction_End;
        if (strcmp(string, "Trigger") == 0) return ReadingContextEnumType_Trigger;
    }
    return 0;
}

const char* ReadingContextEnumType_toString(int type)
{
    switch(type) {
        case ReadingContextEnumType_Interruption_Begin: return "Interruption.Begin";
        case ReadingContextEnumType_Interruption_End: return "Interruption.End";
        case ReadingContextEnumType_Other: return "Other";
        case ReadingContextEnumType_Sample_Clock: return "Sample.Clock";
        case ReadingContextEnumType_Sample_Periodic: return "Sample.Periodic";
        case ReadingContextEnumType_Transaction_Begin: return "Transaction.Begin";
        case ReadingContextEnumType_Transaction_End: return "Transaction.End";
        case ReadingContextEnumType_Trigger: return "Trigger";
    }
    return NULL;
}

// 3.83 
int ReasonEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "DeAuthorized") == 0) return ReasonEnumType_DeAuthorized;
        if (strcmp(string, "EmergencyStop") == 0) return ReasonEnumType_EmergencyStop;
        if (strcmp(string, "EnergyLimitReached") == 0) return ReasonEnumType_EnergyLimitReached;
        if (strcmp(string, "EVDisconnected") == 0) return ReasonEnumType_EVDisconnected;
        if (strcmp(string, "GroundFault") == 0) return ReasonEnumType_GroundFault;
        if (strcmp(string, "ImmediateReset") == 0) return ReasonEnumType_ImmediateReset;
        if (strcmp(string, "MasterPass") == 0) return ReasonEnumType_MasterPass;
        if (strcmp(string, "Local") == 0) return ReasonEnumType_Local;
        if (strcmp(string, "LocalOutOfCredit") == 0) return ReasonEnumType_LocalOutOfCredit;
        if (strcmp(string, "Other") == 0) return ReasonEnumType_Other;
        if (strcmp(string, "OvercurrentFault") == 0) return ReasonEnumType_OvercurrentFault;
        if (strcmp(string, "PowerLoss") == 0) return ReasonEnumType_PowerLoss;
        if (strcmp(string, "PowerQuality") == 0) return ReasonEnumType_PowerQuality;
        if (strcmp(string, "Reboot") == 0) return ReasonEnumType_Reboot;
        if (strcmp(string, "Remote") == 0) return ReasonEnumType_Remote;
        if (strcmp(string, "SOCLimitReached") == 0) return ReasonEnumType_SOCLimitReached;
        if (strcmp(string, "StoppedByEV") == 0) return ReasonEnumType_StoppedByEV;
        if (strcmp(string, "TimeLimitReached") == 0) return ReasonEnumType_TimeLimitReached;
        if (strcmp(string, "Timeout") == 0) return ReasonEnumType_Timeout;
        if (strcmp(string, "ReqEnergyTransferRejected") == 0) return ReasonEnumType_ReqEnergyTransferRejected;
    }
    return 0;
}

const char* ReasonEnumType_toString(int type)
{
    switch(type) {
        case ReasonEnumType_DeAuthorized: return "DeAuthorized";
        case ReasonEnumType_EmergencyStop: return "EmergencyStop";
        case ReasonEnumType_EnergyLimitReached: return "EnergyLimitReached";
        case ReasonEnumType_EVDisconnected: return "EVDisconnected";
        case ReasonEnumType_GroundFault: return "GroundFault";
        case ReasonEnumType_ImmediateReset: return "ImmediateReset";
        case ReasonEnumType_MasterPass: return "MasterPass";
        case ReasonEnumType_Local: return "Local";
        case ReasonEnumType_LocalOutOfCredit: return "LocalOutOfCredit";
        case ReasonEnumType_Other: return "Other";
        case ReasonEnumType_OvercurrentFault: return "OvercurrentFault";
        case ReasonEnumType_PowerLoss: return "PowerLoss";
        case ReasonEnumType_PowerQuality: return "PowerQuality";
        case ReasonEnumType_Reboot: return "Reboot";
        case ReasonEnumType_Remote: return "Remote";
        case ReasonEnumType_SOCLimitReached: return "SOCLimitReached";
        case ReasonEnumType_StoppedByEV: return "StoppedByEV";
        case ReasonEnumType_TimeLimitReached: return "TimeLimitReached";
        case ReasonEnumType_Timeout: return "Timeout";
        case ReasonEnumType_ReqEnergyTransferRejected: return "ReqEnergyTransferRejected";
    }
    return NULL;
}

// 3.84 
int RecurrencyKindEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Daily") == 0) return RecurrencyKindEnumType_Daily;
        if (strcmp(string, "Weekly") == 0) return RecurrencyKindEnumType_Weekly;
    }
    return 0;
}

const char* RecurrencyKindEnumType_toString(int type)
{
    switch(type) {
        case RecurrencyKindEnumType_Daily: return "Daily";
        case RecurrencyKindEnumType_Weekly: return "Weekly";
    }
    return NULL;
}

// 3.85 
int RegistrationStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return RegistrationStatusEnumType_Accepted;
        if (strcmp(string, "Pending") == 0) return RegistrationStatusEnumType_Pending;
        if (strcmp(string, "Rejected") == 0) return RegistrationStatusEnumType_Rejected;
    }
    return 0;
}

const char* RegistrationStatusEnumType_toString(int type)
{
    switch(type) {
        case RegistrationStatusEnumType_Accepted: return "Accepted";
        case RegistrationStatusEnumType_Pending: return "Pending";
        case RegistrationStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

// 3.86 
int ReportBaseEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "ConfigurationInventory") == 0) return ReportBaseEnumType_ConfigurationInventory;
        if (strcmp(string, "FullInventory") == 0) return ReportBaseEnumType_FullInventory;
        if (strcmp(string, "SummaryInventory") == 0) return ReportBaseEnumType_SummaryInventory;
    }
    return 0;
}

const char* ReportBaseEnumType_toString(int type)
{
    switch(type) {
        case ReportBaseEnumType_ConfigurationInventory: return "ConfigurationInventory";
        case ReportBaseEnumType_FullInventory: return "FullInventory";
        case ReportBaseEnumType_SummaryInventory: return "SummaryInventory";
    }
    return NULL;
}

// 3.87 
int RequestStartStopStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return RequestStartStopStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return RequestStartStopStatusEnumType_Rejected;
    }
    return 0;
}

const char* RequestStartStopStatusEnumType_toString(int type)
{
    switch(type) {
        case RequestStartStopStatusEnumType_Accepted: return "Accepted";
        case RequestStartStopStatusEnumType_Rejected: return "Rejected";
    }
    return NULL;
}

// 3.88 
int ReservationUpdateStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Expired") == 0) return ReservationUpdateStatusEnumType_Expired;
        if (strcmp(string, "Removed") == 0) return ReservationUpdateStatusEnumType_Removed;
        if (strcmp(string, "NoTransaction") == 0) return ReservationUpdateStatusEnumType_NoTransaction;
    }
    return 0;
}

const char* ReservationUpdateStatusEnumType_toString(int type)
{
    switch(type) {
        case ReservationUpdateStatusEnumType_Expired: return "Expired";
        case ReservationUpdateStatusEnumType_Removed: return "Removed";
        case ReservationUpdateStatusEnumType_NoTransaction: return "NoTransaction";
    }
    return NULL;
}

// 3.89 
int ReserveNowStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ReserveNowStatusEnumType_Accepted;
        if (strcmp(string, "Faulted") == 0) return ReserveNowStatusEnumType_Faulted;
        if (strcmp(string, "Occupied") == 0) return ReserveNowStatusEnumType_Occupied;
        if (strcmp(string, "Rejected") == 0) return ReserveNowStatusEnumType_Rejected;
        if (strcmp(string, "Unavailable") == 0) return ReserveNowStatusEnumType_Unavailable;
    }
    return 0;
}

const char* ReserveNowStatusEnumType_toString(int type)
{
    switch(type) {
        case ReserveNowStatusEnumType_Accepted: return "Accepted";
        case ReserveNowStatusEnumType_Faulted: return "Faulted";
        case ReserveNowStatusEnumType_Occupied: return "Occupied";
        case ReserveNowStatusEnumType_Rejected: return "Rejected";
        case ReserveNowStatusEnumType_Unavailable: return "Unavailable";
    }
    return NULL;
}

// 3.90 
int ResetEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Immediate") == 0) return ResetEnumType_Immediate;
        if (strcmp(string, "OnIdle") == 0) return ResetEnumType_OnIdle;
        if (strcmp(string, "ImmediateAndResume") == 0) return ResetEnumType_ImmediateAndResume;
    }
    return 0;
}

const char* ResetEnumType_toString(int type)
{
    switch(type) {
        case ResetEnumType_Immediate: return "Immediate";
        case ResetEnumType_OnIdle: return "OnIdle";
        case ResetEnumType_ImmediateAndResume: return "ImmediateAndResume";
    }
    return NULL;
}

// 3.91 
int ResetStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return ResetStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return ResetStatusEnumType_Rejected;
        if (strcmp(string, "Scheduled") == 0) return ResetStatusEnumType_Scheduled;
    }
    return 0;
}

const char* ResetStatusEnumType_toString(int type)
{
    switch(type) {
        case ResetStatusEnumType_Accepted: return "Accepted";
        case ResetStatusEnumType_Rejected: return "Rejected";
        case ResetStatusEnumType_Scheduled: return "Scheduled";
    }
    return NULL;
}

// 3.92 
int SendLocalListStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return SendLocalListStatusEnumType_Accepted;
        if (strcmp(string, "Failed") == 0) return SendLocalListStatusEnumType_Failed;
        if (strcmp(string, "VersionMismatch") == 0) return SendLocalListStatusEnumType_VersionMismatch;
    }
    return 0;
}

const char* SendLocalListStatusEnumType_toString(int type)
{
    switch(type) {
        case SendLocalListStatusEnumType_Accepted: return "Accepted";
        case SendLocalListStatusEnumType_Failed: return "Failed";
        case SendLocalListStatusEnumType_VersionMismatch: return "VersionMismatch";
    }
    return NULL;
}

// 3.93 
int SetMonitoringStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return SetMonitoringStatusEnumType_Accepted;
        if (strcmp(string, "UnknownComponent") == 0) return SetMonitoringStatusEnumType_UnknownComponent;
        if (strcmp(string, "UnknownVariable") == 0) return SetMonitoringStatusEnumType_UnknownVariable;
        if (strcmp(string, "UnsupportedMonitorType") == 0) return SetMonitoringStatusEnumType_UnsupportedMonitorType;
        if (strcmp(string, "Rejected") == 0) return SetMonitoringStatusEnumType_Rejected;
        if (strcmp(string, "Duplicate") == 0) return SetMonitoringStatusEnumType_Duplicate;
    }
    return 0;
}

const char* SetMonitoringStatusEnumType_toString(int type)
{
    switch(type) {
        case SetMonitoringStatusEnumType_Accepted: return "Accepted";
        case SetMonitoringStatusEnumType_UnknownComponent: return "UnknownComponent";
        case SetMonitoringStatusEnumType_UnknownVariable: return "UnknownVariable";
        case SetMonitoringStatusEnumType_UnsupportedMonitorType: return "UnsupportedMonitorType";
        case SetMonitoringStatusEnumType_Rejected: return "Rejected";
        case SetMonitoringStatusEnumType_Duplicate: return "Duplicate";
    }
    return NULL;
}

// 3.94 
int SetNetworkProfileStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return SetNetworkProfileStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return SetNetworkProfileStatusEnumType_Rejected;
        if (strcmp(string, "Failed") == 0) return SetNetworkProfileStatusEnumType_Failed;
    }
    return 0;
}

const char* SetNetworkProfileStatusEnumType_toString(int type)
{
    switch(type) {
        case SetNetworkProfileStatusEnumType_Accepted: return "Accepted";
        case SetNetworkProfileStatusEnumType_Rejected: return "Rejected";
        case SetNetworkProfileStatusEnumType_Failed: return "Failed";
    }
    return NULL;
}

// 3.95 
int SetVariableStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return SetVariableStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return SetVariableStatusEnumType_Rejected;
        if (strcmp(string, "UnknownComponent") == 0) return SetVariableStatusEnumType_UnknownComponent;
        if (strcmp(string, "UnknownVariable") == 0) return SetVariableStatusEnumType_UnknownVariable;
        if (strcmp(string, "NotSupportedAttributeType") == 0) return SetVariableStatusEnumType_NotSupportedAttributeType;
        if (strcmp(string, "RebootRequired") == 0) return SetVariableStatusEnumType_RebootRequired;
    }
    return 0;
}

const char* SetVariableStatusEnumType_toString(int type)
{
    switch(type) {
        case SetVariableStatusEnumType_Accepted: return "Accepted";
        case SetVariableStatusEnumType_Rejected: return "Rejected";
        case SetVariableStatusEnumType_UnknownComponent: return "UnknownComponent";
        case SetVariableStatusEnumType_UnknownVariable: return "UnknownVariable";
        case SetVariableStatusEnumType_NotSupportedAttributeType: return "NotSupportedAttributeType";
        case SetVariableStatusEnumType_RebootRequired: return "RebootRequired";
    }
    return NULL;
}

// 3.96 
int TariffChangeStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return TariffChangeStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return TariffChangeStatusEnumType_Rejected;
        if (strcmp(string, "TooManyElements") == 0) return TariffChangeStatusEnumType_TooManyElements;
        if (strcmp(string, "ConditionNotSupported") == 0) return TariffChangeStatusEnumType_ConditionNotSupported;
        if (strcmp(string, "TxNotFound") == 0) return TariffChangeStatusEnumType_TxNotFound;
        if (strcmp(string, "NoCurrencyChange") == 0) return TariffChangeStatusEnumType_NoCurrencyChange;
    }
    return 0;
}

const char* TariffChangeStatusEnumType_toString(int type)
{
    switch(type) {
        case TariffChangeStatusEnumType_Accepted: return "Accepted";
        case TariffChangeStatusEnumType_Rejected: return "Rejected";
        case TariffChangeStatusEnumType_TooManyElements: return "TooManyElements";
        case TariffChangeStatusEnumType_ConditionNotSupported: return "ConditionNotSupported";
        case TariffChangeStatusEnumType_TxNotFound: return "TxNotFound";
        case TariffChangeStatusEnumType_NoCurrencyChange: return "NoCurrencyChange";
    }
    return NULL;
}

// 3.97 
int TariffClearStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return TariffClearStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return TariffClearStatusEnumType_Rejected;
        if (strcmp(string, "NoTariff") == 0) return TariffClearStatusEnumType_NoTariff;
    }
    return 0;
}

const char* TariffClearStatusEnumType_toString(int type)
{
    switch(type) {
        case TariffClearStatusEnumType_Accepted: return "Accepted";
        case TariffClearStatusEnumType_Rejected: return "Rejected";
        case TariffClearStatusEnumType_NoTariff: return "NoTariff";
    }
    return NULL;
}

// 3.98 
int TariffCostEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "NormalCost") == 0) return TariffCostEnumType_NormalCost;
        if (strcmp(string, "MinCost") == 0) return TariffCostEnumType_MinCost;
        if (strcmp(string, "MaxCost") == 0) return TariffCostEnumType_MaxCost;
    }
    return 0;
}

const char* TariffCostEnumType_toString(int type)
{
    switch(type) {
        case TariffCostEnumType_NormalCost: return "NormalCost";
        case TariffCostEnumType_MinCost: return "MinCost";
        case TariffCostEnumType_MaxCost: return "MaxCost";
    }
    return NULL;
}

// 3.99 
int TariffGetStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return TariffGetStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return TariffGetStatusEnumType_Rejected;
        if (strcmp(string, "NoTariff") == 0) return TariffGetStatusEnumType_NoTariff;
    }
    return 0;
}

const char* TariffGetStatusEnumType_toString(int type)
{
    switch(type) {
        case TariffGetStatusEnumType_Accepted: return "Accepted";
        case TariffGetStatusEnumType_Rejected: return "Rejected";
        case TariffGetStatusEnumType_NoTariff: return "NoTariff";
    }
    return NULL;
}

// 3.100 
int TariffKindEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "DefaultTariff") == 0) return TariffKindEnumType_DefaultTariff;
        if (strcmp(string, "DriverTariff") == 0) return TariffKindEnumType_DriverTariff;
    }
    return 0;
}

const char* TariffKindEnumType_toString(int type)
{
    switch(type) {
        case TariffKindEnumType_DefaultTariff: return "DefaultTariff";
        case TariffKindEnumType_DriverTariff: return "DriverTariff";
    }
    return NULL;
}

// 3.101 
int TariffSetStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return TariffSetStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return TariffSetStatusEnumType_Rejected;
        if (strcmp(string, "TooManyElements") == 0) return TariffSetStatusEnumType_TooManyElements;
        if (strcmp(string, "ConditionNotSupported") == 0) return TariffSetStatusEnumType_ConditionNotSupported;
        if (strcmp(string, "DuplicateTariffId") == 0) return TariffSetStatusEnumType_DuplicateTariffId;
    }
    return 0;
}

const char* TariffSetStatusEnumType_toString(int type)
{
    switch(type) {
        case TariffSetStatusEnumType_Accepted: return "Accepted";
        case TariffSetStatusEnumType_Rejected: return "Rejected";
        case TariffSetStatusEnumType_TooManyElements: return "TooManyElements";
        case TariffSetStatusEnumType_ConditionNotSupported: return "ConditionNotSupported";
        case TariffSetStatusEnumType_DuplicateTariffId: return "DuplicateTariffId";
    }
    return NULL;
}

// 3.102 
int TransactionEventEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Ended") == 0) return TransactionEventEnumType_Ended;
        if (strcmp(string, "Started") == 0) return TransactionEventEnumType_Started;
        if (strcmp(string, "Updated") == 0) return TransactionEventEnumType_Updated;
    }
    return 0;
}

const char* TransactionEventEnumType_toString(int type)
{
    switch(type) {
        case TransactionEventEnumType_Ended: return "Ended";
        case TransactionEventEnumType_Started: return "Started";
        case TransactionEventEnumType_Updated: return "Updated";
    }
    return NULL;
}

// 3.103 
int TriggerMessageStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return TriggerMessageStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return TriggerMessageStatusEnumType_Rejected;
        if (strcmp(string, "NotImplemented") == 0) return TriggerMessageStatusEnumType_NotImplemented;
    }
    return 0;
}

const char* TriggerMessageStatusEnumType_toString(int type)
{
    switch(type) {
        case TriggerMessageStatusEnumType_Accepted: return "Accepted";
        case TriggerMessageStatusEnumType_Rejected: return "Rejected";
        case TriggerMessageStatusEnumType_NotImplemented: return "NotImplemented";
    }
    return NULL;
}

// 3.104 
int TriggerReasonEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "AbnormalCondition") == 0) return TriggerReasonEnumType_AbnormalCondition;
        if (strcmp(string, "Authorized") == 0) return TriggerReasonEnumType_Authorized;
        if (strcmp(string, "CablePluggedIn") == 0) return TriggerReasonEnumType_CablePluggedIn;
        if (strcmp(string, "ChargingRateChanged") == 0) return TriggerReasonEnumType_ChargingRateChanged;
        if (strcmp(string, "ChargingStateChanged") == 0) return TriggerReasonEnumType_ChargingStateChanged;
        if (strcmp(string, "CostLimitReached") == 0) return TriggerReasonEnumType_CostLimitReached;
        if (strcmp(string, "Deauthorized") == 0) return TriggerReasonEnumType_Deauthorized;
        if (strcmp(string, "EnergyLimitReached") == 0) return TriggerReasonEnumType_EnergyLimitReached;
        if (strcmp(string, "EVCommunicationLost") == 0) return TriggerReasonEnumType_EVCommunicationLost;
        if (strcmp(string, "EVConnectTimeout") == 0) return TriggerReasonEnumType_EVConnectTimeout;
        if (strcmp(string, "EVDeparted") == 0) return TriggerReasonEnumType_EVDeparted;
        if (strcmp(string, "EVDetected") == 0) return TriggerReasonEnumType_EVDetected;
        if (strcmp(string, "LimitSet") == 0) return TriggerReasonEnumType_LimitSet;
        if (strcmp(string, "MeterValueClock") == 0) return TriggerReasonEnumType_MeterValueClock;
        if (strcmp(string, "MeterValuePeriodic") == 0) return TriggerReasonEnumType_MeterValuePeriodic;
        if (strcmp(string, "OperationModeChanged") == 0) return TriggerReasonEnumType_OperationModeChanged;
        if (strcmp(string, "RemoteStart") == 0) return TriggerReasonEnumType_RemoteStart;
        if (strcmp(string, "RemoteStop") == 0) return TriggerReasonEnumType_RemoteStop;
        if (strcmp(string, "ResetCommand") == 0) return TriggerReasonEnumType_ResetCommand;
        if (strcmp(string, "RunningCost") == 0) return TriggerReasonEnumType_RunningCost;
        if (strcmp(string, "SignedDataReceived") == 0) return TriggerReasonEnumType_SignedDataReceived;
        if (strcmp(string, "SoCLimitReached") == 0) return TriggerReasonEnumType_SoCLimitReached;
        if (strcmp(string, "StopAuthorized") == 0) return TriggerReasonEnumType_StopAuthorized;
        if (strcmp(string, "TariffChanged") == 0) return TriggerReasonEnumType_TariffChanged;
        if (strcmp(string, "TariffNotAccepted") == 0) return TriggerReasonEnumType_TariffNotAccepted;
        if (strcmp(string, "TimeLimitReached") == 0) return TriggerReasonEnumType_TimeLimitReached;
        if (strcmp(string, "Trigger") == 0) return TriggerReasonEnumType_Trigger;
        if (strcmp(string, "TxResumed") == 0) return TriggerReasonEnumType_TxResumed;
        if (strcmp(string, "UnlockCommand") == 0) return TriggerReasonEnumType_UnlockCommand;
    }
    return 0;
}

const char* TriggerReasonEnumType_toString(int type)
{
    switch(type) {
        case TriggerReasonEnumType_AbnormalCondition: return "AbnormalCondition";
        case TriggerReasonEnumType_Authorized: return "Authorized";
        case TriggerReasonEnumType_CablePluggedIn: return "CablePluggedIn";
        case TriggerReasonEnumType_ChargingRateChanged: return "ChargingRateChanged";
        case TriggerReasonEnumType_ChargingStateChanged: return "ChargingStateChanged";
        case TriggerReasonEnumType_CostLimitReached: return "CostLimitReached";
        case TriggerReasonEnumType_Deauthorized: return "Deauthorized";
        case TriggerReasonEnumType_EnergyLimitReached: return "EnergyLimitReached";
        case TriggerReasonEnumType_EVCommunicationLost: return "EVCommunicationLost";
        case TriggerReasonEnumType_EVConnectTimeout: return "EVConnectTimeout";
        case TriggerReasonEnumType_EVDeparted: return "EVDeparted";
        case TriggerReasonEnumType_EVDetected: return "EVDetected";
        case TriggerReasonEnumType_LimitSet: return "LimitSet";
        case TriggerReasonEnumType_MeterValueClock: return "MeterValueClock";
        case TriggerReasonEnumType_MeterValuePeriodic: return "MeterValuePeriodic";
        case TriggerReasonEnumType_OperationModeChanged: return "OperationModeChanged";
        case TriggerReasonEnumType_RemoteStart: return "RemoteStart";
        case TriggerReasonEnumType_RemoteStop: return "RemoteStop";
        case TriggerReasonEnumType_ResetCommand: return "ResetCommand";
        case TriggerReasonEnumType_RunningCost: return "RunningCost";
        case TriggerReasonEnumType_SignedDataReceived: return "SignedDataReceived";
        case TriggerReasonEnumType_SoCLimitReached: return "SoCLimitReached";
        case TriggerReasonEnumType_StopAuthorized: return "StopAuthorized";
        case TriggerReasonEnumType_TariffChanged: return "TariffChanged";
        case TriggerReasonEnumType_TariffNotAccepted: return "TariffNotAccepted";
        case TriggerReasonEnumType_TimeLimitReached: return "TimeLimitReached";
        case TriggerReasonEnumType_Trigger: return "Trigger";
        case TriggerReasonEnumType_TxResumed: return "TxResumed";
        case TriggerReasonEnumType_UnlockCommand: return "UnlockCommand";
    }
    return NULL;
}

// 3.105 
int UnlockStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Unlocked") == 0) return UnlockStatusEnumType_Unlocked;
        if (strcmp(string, "UnlockFailed") == 0) return UnlockStatusEnumType_UnlockFailed;
        if (strcmp(string, "OngoingAuthorizedTransaction") == 0) return UnlockStatusEnumType_OngoingAuthorizedTransaction;
        if (strcmp(string, "UnknownConnector") == 0) return UnlockStatusEnumType_UnknownConnector;
    }
    return 0;
}

const char* UnlockStatusEnumType_toString(int type)
{
    switch(type) {
        case UnlockStatusEnumType_Unlocked: return "Unlocked";
        case UnlockStatusEnumType_UnlockFailed: return "UnlockFailed";
        case UnlockStatusEnumType_OngoingAuthorizedTransaction: return "OngoingAuthorizedTransaction";
        case UnlockStatusEnumType_UnknownConnector: return "UnknownConnector";
    }
    return NULL;
}

// 3.106 
int UnpublishFirmwareStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "DownloadOngoing") == 0) return UnpublishFirmwareStatusEnumType_DownloadOngoing;
        if (strcmp(string, "NoFirmware") == 0) return UnpublishFirmwareStatusEnumType_NoFirmware;
        if (strcmp(string, "Unpublished") == 0) return UnpublishFirmwareStatusEnumType_Unpublished;
    }
    return 0;
}

const char* UnpublishFirmwareStatusEnumType_toString(int type)
{
    switch(type) {
        case UnpublishFirmwareStatusEnumType_DownloadOngoing: return "DownloadOngoing";
        case UnpublishFirmwareStatusEnumType_NoFirmware: return "NoFirmware";
        case UnpublishFirmwareStatusEnumType_Unpublished: return "Unpublished";
    }
    return NULL;
}

// 3.107 
int UpdateEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Differential") == 0) return UpdateEnumType_Differential;
        if (strcmp(string, "Full") == 0) return UpdateEnumType_Full;
    }
    return 0;
}

const char* UpdateEnumType_toString(int type)
{
    switch(type) {
        case UpdateEnumType_Differential: return "Differential";
        case UpdateEnumType_Full: return "Full";
    }
    return NULL;
}

// 3.108 
int UpdateFirmwareStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "Accepted") == 0) return UpdateFirmwareStatusEnumType_Accepted;
        if (strcmp(string, "Rejected") == 0) return UpdateFirmwareStatusEnumType_Rejected;
        if (strcmp(string, "AcceptedCanceled") == 0) return UpdateFirmwareStatusEnumType_AcceptedCanceled;
        if (strcmp(string, "InvalidCertificate") == 0) return UpdateFirmwareStatusEnumType_InvalidCertificate;
        if (strcmp(string, "RevokedCertificate") == 0) return UpdateFirmwareStatusEnumType_RevokedCertificate;
    }
    return 0;
}

const char* UpdateFirmwareStatusEnumType_toString(int type)
{
    switch(type) {
        case UpdateFirmwareStatusEnumType_Accepted: return "Accepted";
        case UpdateFirmwareStatusEnumType_Rejected: return "Rejected";
        case UpdateFirmwareStatusEnumType_AcceptedCanceled: return "AcceptedCanceled";
        case UpdateFirmwareStatusEnumType_InvalidCertificate: return "InvalidCertificate";
        case UpdateFirmwareStatusEnumType_RevokedCertificate: return "RevokedCertificate";
    }
    return NULL;
}

// 3.109 
int UploadLogStatusEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "BadMessage") == 0) return UploadLogStatusEnumType_BadMessage;
        if (strcmp(string, "Idle") == 0) return UploadLogStatusEnumType_Idle;
        if (strcmp(string, "NotSupportedOperation") == 0) return UploadLogStatusEnumType_NotSupportedOperation;
        if (strcmp(string, "PermissionDenied") == 0) return UploadLogStatusEnumType_PermissionDenied;
        if (strcmp(string, "Uploaded") == 0) return UploadLogStatusEnumType_Uploaded;
        if (strcmp(string, "UploadFailure") == 0) return UploadLogStatusEnumType_UploadFailure;
        if (strcmp(string, "Uploading") == 0) return UploadLogStatusEnumType_Uploading;
        if (strcmp(string, "AcceptedCanceled") == 0) return UploadLogStatusEnumType_AcceptedCanceled;
    }
    return 0;
}

const char* UploadLogStatusEnumType_toString(int type)
{
    switch(type) {
        case UploadLogStatusEnumType_BadMessage: return "BadMessage";
        case UploadLogStatusEnumType_Idle: return "Idle";
        case UploadLogStatusEnumType_NotSupportedOperation: return "NotSupportedOperation";
        case UploadLogStatusEnumType_PermissionDenied: return "PermissionDenied";
        case UploadLogStatusEnumType_Uploaded: return "Uploaded";
        case UploadLogStatusEnumType_UploadFailure: return "UploadFailure";
        case UploadLogStatusEnumType_Uploading: return "Uploading";
        case UploadLogStatusEnumType_AcceptedCanceled: return "AcceptedCanceled";
    }
    return NULL;
}

// 3.110 
int VPNEnumType_fromString(const char *string)
{
    if (string) {
        if (strcmp(string, "IKEv2") == 0) return VPNEnumType_IKEv2;
        if (strcmp(string, "IPSec") == 0) return VPNEnumType_IPSec;
        if (strcmp(string, "L2TP") == 0) return VPNEnumType_L2TP;
        if (strcmp(string, "PPTP") == 0) return VPNEnumType_PPTP;
    }
    return 0;
}

const char* VPNEnumType_toString(int type)
{
    switch(type) {
        case VPNEnumType_IKEv2: return "IKEv2";
        case VPNEnumType_IPSec: return "IPSec";
        case VPNEnumType_L2TP: return "L2TP";
        case VPNEnumType_PPTP: return "PPTP";
    }
    return NULL;
}