@citrineos/base/dist/src/ocpp/model/2.1/enums/index.js

The base module for OCPP v2.0.1 including all interfaces. This module is not intended to be used directly, but rather as a dependency for other modules.

// SPDX-FileCopyrightText: 2025 Contributors to the CitrineOS Project
//
// SPDX-License-Identifier: Apache-2.0
/**
 * Enumeration of possible idToken types.
 * Imported from 2.0.1
 *
 */
export var IdTokenEnumType;
(function (IdTokenEnumType) {
    IdTokenEnumType["Central"] = "Central";
    IdTokenEnumType["DirectPayment"] = "DirectPayment";
    IdTokenEnumType["eMAID"] = "eMAID";
    IdTokenEnumType["EVCCID"] = "EVCCID";
    IdTokenEnumType["ISO14443"] = "ISO14443";
    IdTokenEnumType["ISO15693"] = "ISO15693";
    IdTokenEnumType["KeyCode"] = "KeyCode";
    IdTokenEnumType["Local"] = "Local";
    IdTokenEnumType["MacAddress"] = "MacAddress";
    IdTokenEnumType["NoAuthorization"] = "NoAuthorization";
    IdTokenEnumType["VIN"] = "VIN";
})(IdTokenEnumType || (IdTokenEnumType = {}));
/**
 * Source that has installed this charging profile.
 * Imported from 2.0.1
 *
 */
export var ChargingLimitSourceEnumType;
(function (ChargingLimitSourceEnumType) {
    ChargingLimitSourceEnumType["EMS"] = "EMS";
    ChargingLimitSourceEnumType["Other"] = "Other";
    ChargingLimitSourceEnumType["SO"] = "SO";
    ChargingLimitSourceEnumType["CSO"] = "CSO";
})(ChargingLimitSourceEnumType || (ChargingLimitSourceEnumType = {}));
/**
 * *(2.1)* Indicates whether EV wants to operate in Dynamic or Scheduled mode. When absent, Scheduled mode is assumed for backwards compatibility. +
 * *ISO 15118-20:* +
 * ServiceSelectionReq(SelectedEnergyTransferService)
 *
 */
export var ControlModeEnumType;
(function (ControlModeEnumType) {
    ControlModeEnumType["ScheduledControl"] = "ScheduledControl";
    ControlModeEnumType["DynamicControl"] = "DynamicControl";
})(ControlModeEnumType || (ControlModeEnumType = {}));
/**
 * *(2.1)* The _operationMode_ that is currently in effect for the transaction.
 *
 */
export var OperationModeEnumType;
(function (OperationModeEnumType) {
    OperationModeEnumType["Idle"] = "Idle";
    OperationModeEnumType["ChargingOnly"] = "ChargingOnly";
    OperationModeEnumType["CentralSetpoint"] = "CentralSetpoint";
    OperationModeEnumType["ExternalSetpoint"] = "ExternalSetpoint";
    OperationModeEnumType["ExternalLimits"] = "ExternalLimits";
    OperationModeEnumType["CentralFrequency"] = "CentralFrequency";
    OperationModeEnumType["LocalFrequency"] = "LocalFrequency";
    OperationModeEnumType["LocalLoadBalancing"] = "LocalLoadBalancing";
})(OperationModeEnumType || (OperationModeEnumType = {}));
/**
 * *(2.1)* The current preconditioning status of the BMS in the EV. Default value is Unknown.
 *
 */
export var PreconditioningStatusEnumType;
(function (PreconditioningStatusEnumType) {
    PreconditioningStatusEnumType["Unknown"] = "Unknown";
    PreconditioningStatusEnumType["Ready"] = "Ready";
    PreconditioningStatusEnumType["NotReady"] = "NotReady";
    PreconditioningStatusEnumType["Preconditioning"] = "Preconditioning";
})(PreconditioningStatusEnumType || (PreconditioningStatusEnumType = {}));
/**
 * *(2.1)* This field is ignored, since the OCPP version to use is determined during the websocket handshake. The field is only kept for backwards compatibility with the OCPP 2.0.1 JSON schema.
 *
 */
export var OCPPVersionEnumType;
(function (OCPPVersionEnumType) {
    OCPPVersionEnumType["OCPP12"] = "OCPP12";
    OCPPVersionEnumType["OCPP15"] = "OCPP15";
    OCPPVersionEnumType["OCPP16"] = "OCPP16";
    OCPPVersionEnumType["OCPP20"] = "OCPP20";
    OCPPVersionEnumType["OCPP201"] = "OCPP201";
    OCPPVersionEnumType["OCPP21"] = "OCPP21";
})(OCPPVersionEnumType || (OCPPVersionEnumType = {}));
/**
 * *(2.1)* Type of monitor.
 *
 */
export var EventNotificationEnumType;
(function (EventNotificationEnumType) {
    EventNotificationEnumType["HardWiredNotification"] = "HardWiredNotification";
    EventNotificationEnumType["HardWiredMonitor"] = "HardWiredMonitor";
    EventNotificationEnumType["PreconfiguredMonitor"] = "PreconfiguredMonitor";
    EventNotificationEnumType["CustomMonitor"] = "CustomMonitor";
})(EventNotificationEnumType || (EventNotificationEnumType = {}));
/**
 * *(2.1)* Value of EVCC indicates that EV determines min/target SOC and departure time. +
 * A value of EVCC_SECC indicates that charging station or CSMS may also update min/target SOC and departure time. +
 * *ISO 15118-20:* +
 * ServiceSelectionReq(SelectedEnergyTransferService)
 *
 */
export var MobilityNeedsModeEnumType;
(function (MobilityNeedsModeEnumType) {
    MobilityNeedsModeEnumType["EVCC"] = "EVCC";
    MobilityNeedsModeEnumType["EVCC_SECC"] = "EVCC_SECC";
})(MobilityNeedsModeEnumType || (MobilityNeedsModeEnumType = {}));
/**
 * Accepted if the Charging Station has executed the request, otherwise rejected.
 *
 */
export var ClearCacheStatusEnumType;
(function (ClearCacheStatusEnumType) {
    ClearCacheStatusEnumType["Accepted"] = "Accepted";
    ClearCacheStatusEnumType["Rejected"] = "Rejected";
})(ClearCacheStatusEnumType || (ClearCacheStatusEnumType = {}));
/**
 * Applicable Network Interface. Charging Station is allowed to use a different network interface to connect if the given one does not work.
 *
 */
export var OCPPInterfaceEnumType;
(function (OCPPInterfaceEnumType) {
    OCPPInterfaceEnumType["Wired0"] = "Wired0";
    OCPPInterfaceEnumType["Wired1"] = "Wired1";
    OCPPInterfaceEnumType["Wired2"] = "Wired2";
    OCPPInterfaceEnumType["Wired3"] = "Wired3";
    OCPPInterfaceEnumType["Wireless0"] = "Wireless0";
    OCPPInterfaceEnumType["Wireless1"] = "Wireless1";
    OCPPInterfaceEnumType["Wireless2"] = "Wireless2";
    OCPPInterfaceEnumType["Wireless3"] = "Wireless3";
    OCPPInterfaceEnumType["Any"] = "Any";
})(OCPPInterfaceEnumType || (OCPPInterfaceEnumType = {}));
/**
 * Authentication method.
 *
 */
export var APNAuthenticationEnumType;
(function (APNAuthenticationEnumType) {
    APNAuthenticationEnumType["PAP"] = "PAP";
    APNAuthenticationEnumType["CHAP"] = "CHAP";
    APNAuthenticationEnumType["NONE"] = "NONE";
    APNAuthenticationEnumType["AUTO"] = "AUTO";
})(APNAuthenticationEnumType || (APNAuthenticationEnumType = {}));
/**
 * Battery in/out
 *
 */
export var BatterySwapEventEnumType;
(function (BatterySwapEventEnumType) {
    BatterySwapEventEnumType["BatteryIn"] = "BatteryIn";
    BatterySwapEventEnumType["BatteryOut"] = "BatteryOut";
    BatterySwapEventEnumType["BatteryOutTimeout"] = "BatteryOutTimeout";
})(BatterySwapEventEnumType || (BatterySwapEventEnumType = {}));
/**
 * Certificate status information.
 * - if all certificates are valid: return 'Accepted'.
 * - if one of the certificates was revoked, return 'CertificateRevoked'.
 *
 */
export var AuthorizeCertificateStatusEnumType;
(function (AuthorizeCertificateStatusEnumType) {
    AuthorizeCertificateStatusEnumType["Accepted"] = "Accepted";
    AuthorizeCertificateStatusEnumType["SignatureError"] = "SignatureError";
    AuthorizeCertificateStatusEnumType["CertificateExpired"] = "CertificateExpired";
    AuthorizeCertificateStatusEnumType["CertificateRevoked"] = "CertificateRevoked";
    AuthorizeCertificateStatusEnumType["NoCertificateAvailable"] = "NoCertificateAvailable";
    AuthorizeCertificateStatusEnumType["CertChainError"] = "CertChainError";
    AuthorizeCertificateStatusEnumType["ContractCancelled"] = "ContractCancelled";
})(AuthorizeCertificateStatusEnumType || (AuthorizeCertificateStatusEnumType = {}));
/**
 * Charging Station indicates if installation was successful.
 *
 */
export var InstallCertificateStatusEnumType;
(function (InstallCertificateStatusEnumType) {
    InstallCertificateStatusEnumType["Accepted"] = "Accepted";
    InstallCertificateStatusEnumType["Rejected"] = "Rejected";
    InstallCertificateStatusEnumType["Failed"] = "Failed";
})(InstallCertificateStatusEnumType || (InstallCertificateStatusEnumType = {}));
/**
 * Charging Station indicates if it can process the request.
 *
 */
export var DeleteCertificateStatusEnumType;
(function (DeleteCertificateStatusEnumType) {
    DeleteCertificateStatusEnumType["Accepted"] = "Accepted";
    DeleteCertificateStatusEnumType["Failed"] = "Failed";
    DeleteCertificateStatusEnumType["NotFound"] = "NotFound";
})(DeleteCertificateStatusEnumType || (DeleteCertificateStatusEnumType = {}));
/**
 * Charging Station indicates if it can process the request.
 *
 */
export var GetInstalledCertificateStatusEnumType;
(function (GetInstalledCertificateStatusEnumType) {
    GetInstalledCertificateStatusEnumType["Accepted"] = "Accepted";
    GetInstalledCertificateStatusEnumType["NotFound"] = "NotFound";
})(GetInstalledCertificateStatusEnumType || (GetInstalledCertificateStatusEnumType = {}));
/**
 * Current charging state, is required when state
 * has changed. Omitted when there is no communication between EVSE and EV, because no cable is plugged in.
 *
 */
export var ChargingStateEnumType;
(function (ChargingStateEnumType) {
    ChargingStateEnumType["EVConnected"] = "EVConnected";
    ChargingStateEnumType["Charging"] = "Charging";
    ChargingStateEnumType["SuspendedEV"] = "SuspendedEV";
    ChargingStateEnumType["SuspendedEVSE"] = "SuspendedEVSE";
    ChargingStateEnumType["Idle"] = "Idle";
})(ChargingStateEnumType || (ChargingStateEnumType = {}));
/**
 * Current status of the ID Token.
 *
 */
export var AuthorizationStatusEnumType;
(function (AuthorizationStatusEnumType) {
    AuthorizationStatusEnumType["Accepted"] = "Accepted";
    AuthorizationStatusEnumType["Blocked"] = "Blocked";
    AuthorizationStatusEnumType["ConcurrentTx"] = "ConcurrentTx";
    AuthorizationStatusEnumType["Expired"] = "Expired";
    AuthorizationStatusEnumType["Invalid"] = "Invalid";
    AuthorizationStatusEnumType["NoCredit"] = "NoCredit";
    AuthorizationStatusEnumType["NotAllowedTypeEVSE"] = "NotAllowedTypeEVSE";
    AuthorizationStatusEnumType["NotAtThisLocation"] = "NotAtThisLocation";
    AuthorizationStatusEnumType["NotAtThisTime"] = "NotAtThisTime";
    AuthorizationStatusEnumType["Unknown"] = "Unknown";
})(AuthorizationStatusEnumType || (AuthorizationStatusEnumType = {}));
/**
 * Data type of this variable.
 *
 */
export var DataEnumType;
(function (DataEnumType) {
    DataEnumType["string"] = "string";
    DataEnumType["decimal"] = "decimal";
    DataEnumType["integer"] = "integer";
    DataEnumType["dateTime"] = "dateTime";
    DataEnumType["boolean"] = "boolean";
    DataEnumType["OptionList"] = "OptionList";
    DataEnumType["SequenceList"] = "SequenceList";
    DataEnumType["MemberList"] = "MemberList";
    DataEnumType["passwordString"] = "passwordString";
})(DataEnumType || (DataEnumType = {}));
/**
 * Defines the mutability of this attribute. Default is ReadWrite when omitted.
 *
 */
export var MutabilityEnumType;
(function (MutabilityEnumType) {
    MutabilityEnumType["ReadOnly"] = "ReadOnly";
    MutabilityEnumType["WriteOnly"] = "WriteOnly";
    MutabilityEnumType["ReadWrite"] = "ReadWrite";
})(MutabilityEnumType || (MutabilityEnumType = {}));
/**
 * Defines the purpose of the schedule transferred by this profile
 *
 */
export var ChargingProfilePurposeEnumType;
(function (ChargingProfilePurposeEnumType) {
    ChargingProfilePurposeEnumType["ChargingStationExternalConstraints"] = "ChargingStationExternalConstraints";
    ChargingProfilePurposeEnumType["ChargingStationMaxProfile"] = "ChargingStationMaxProfile";
    ChargingProfilePurposeEnumType["TxDefaultProfile"] = "TxDefaultProfile";
    ChargingProfilePurposeEnumType["TxProfile"] = "TxProfile";
    ChargingProfilePurposeEnumType["PriorityCharging"] = "PriorityCharging";
    ChargingProfilePurposeEnumType["LocalGeneration"] = "LocalGeneration";
})(ChargingProfilePurposeEnumType || (ChargingProfilePurposeEnumType = {}));
/**
 * Defines the transport protocol (e.g. SOAP or JSON). Note: SOAP is not supported in OCPP 2.x, but is supported by earlier versions of OCPP.
 *
 */
export var OCPPTransportEnumType;
(function (OCPPTransportEnumType) {
    OCPPTransportEnumType["SOAP"] = "SOAP";
    OCPPTransportEnumType["JSON"] = "JSON";
})(OCPPTransportEnumType || (OCPPTransportEnumType = {}));
/**
 * Defines whether certificate needs to be installed or updated.
 *
 */
export var CertificateActionEnumType;
(function (CertificateActionEnumType) {
    CertificateActionEnumType["Install"] = "Install";
    CertificateActionEnumType["Update"] = "Update";
})(CertificateActionEnumType || (CertificateActionEnumType = {}));
/**
 * During what state should this message be shown. When omitted this message should be shown in any state of the Charging Station.
 *
 */
export var MessageStateEnumType;
(function (MessageStateEnumType) {
    MessageStateEnumType["Charging"] = "Charging";
    MessageStateEnumType["Faulted"] = "Faulted";
    MessageStateEnumType["Idle"] = "Idle";
    MessageStateEnumType["Unavailable"] = "Unavailable";
    MessageStateEnumType["Suspended"] = "Suspended";
    MessageStateEnumType["Discharging"] = "Discharging";
})(MessageStateEnumType || (MessageStateEnumType = {}));
/**
 * Format of the message.
 *
 */
export var MessageFormatEnumType;
(function (MessageFormatEnumType) {
    MessageFormatEnumType["ASCII"] = "ASCII";
    MessageFormatEnumType["HTML"] = "HTML";
    MessageFormatEnumType["URI"] = "URI";
    MessageFormatEnumType["UTF8"] = "UTF8";
    MessageFormatEnumType["QRCODE"] = "QRCODE";
})(MessageFormatEnumType || (MessageFormatEnumType = {}));
/**
 * Indicates how the measured value is to be interpreted. For instance between L1 and neutral (L1-N) Please note that not all values of phase are applicable to all Measurands. When phase is absent, the measured value is interpreted as an overall value.
 *
 */
export var PhaseEnumType;
(function (PhaseEnumType) {
    PhaseEnumType["L1"] = "L1";
    PhaseEnumType["L2"] = "L2";
    PhaseEnumType["L3"] = "L3";
    PhaseEnumType["N"] = "N";
    PhaseEnumType["L1_N"] = "L1-N";
    PhaseEnumType["L2_N"] = "L2-N";
    PhaseEnumType["L3_N"] = "L3-N";
    PhaseEnumType["L1_L2"] = "L1-L2";
    PhaseEnumType["L2_L3"] = "L2-L3";
    PhaseEnumType["L3_L1"] = "L3-L1";
})(PhaseEnumType || (PhaseEnumType = {}));
/**
 * Indicates if the Charging Station has Display Messages that match the request criteria in the <<getdisplaymessagesrequest,GetDisplayMessagesRequest>>
 *
 */
export var GetDisplayMessagesStatusEnumType;
(function (GetDisplayMessagesStatusEnumType) {
    GetDisplayMessagesStatusEnumType["Accepted"] = "Accepted";
    GetDisplayMessagesStatusEnumType["Unknown"] = "Unknown";
})(GetDisplayMessagesStatusEnumType || (GetDisplayMessagesStatusEnumType = {}));
/**
 * Indicates if the Charging Station was able to execute the request.
 *
 */
export var ClearChargingProfileStatusEnumType;
(function (ClearChargingProfileStatusEnumType) {
    ClearChargingProfileStatusEnumType["Accepted"] = "Accepted";
    ClearChargingProfileStatusEnumType["Unknown"] = "Unknown";
})(ClearChargingProfileStatusEnumType || (ClearChargingProfileStatusEnumType = {}));
/**
 * Indicates the certificate type that is sent.
 *
 */
export var InstallCertificateUseEnumType;
(function (InstallCertificateUseEnumType) {
    InstallCertificateUseEnumType["V2GRootCertificate"] = "V2GRootCertificate";
    InstallCertificateUseEnumType["MORootCertificate"] = "MORootCertificate";
    InstallCertificateUseEnumType["ManufacturerRootCertificate"] = "ManufacturerRootCertificate";
    InstallCertificateUseEnumType["CSMSRootCertificate"] = "CSMSRootCertificate";
    InstallCertificateUseEnumType["OEMRootCertificate"] = "OEMRootCertificate";
})(InstallCertificateUseEnumType || (InstallCertificateUseEnumType = {}));
/**
 * Indicates the kind of schedule.
 *
 */
export var ChargingProfileKindEnumType;
(function (ChargingProfileKindEnumType) {
    ChargingProfileKindEnumType["Absolute"] = "Absolute";
    ChargingProfileKindEnumType["Recurring"] = "Recurring";
    ChargingProfileKindEnumType["Relative"] = "Relative";
    ChargingProfileKindEnumType["Dynamic"] = "Dynamic";
})(ChargingProfileKindEnumType || (ChargingProfileKindEnumType = {}));
/**
 * Indicates the start point of a recurrence.
 *
 */
export var RecurrencyKindEnumType;
(function (RecurrencyKindEnumType) {
    RecurrencyKindEnumType["Daily"] = "Daily";
    RecurrencyKindEnumType["Weekly"] = "Weekly";
})(RecurrencyKindEnumType || (RecurrencyKindEnumType = {}));
/**
 * Indicates the type of certificate that is to be signed. When omitted the certificate is to be used for both the 15118 connection (if implemented) and the Charging Station to CSMS connection.
 *
 *
 */
export var CertificateSigningUseEnumType;
(function (CertificateSigningUseEnumType) {
    CertificateSigningUseEnumType["ChargingStationCertificate"] = "ChargingStationCertificate";
    CertificateSigningUseEnumType["V2GCertificate"] = "V2GCertificate";
    CertificateSigningUseEnumType["V2G20Certificate"] = "V2G20Certificate";
})(CertificateSigningUseEnumType || (CertificateSigningUseEnumType = {}));
/**
 * Indicates the type of the requested certificate(s).
 *
 */
export var GetCertificateIdUseEnumType;
(function (GetCertificateIdUseEnumType) {
    GetCertificateIdUseEnumType["V2GRootCertificate"] = "V2GRootCertificate";
    GetCertificateIdUseEnumType["MORootCertificate"] = "MORootCertificate";
    GetCertificateIdUseEnumType["CSMSRootCertificate"] = "CSMSRootCertificate";
    GetCertificateIdUseEnumType["V2GCertificateChain"] = "V2GCertificateChain";
    GetCertificateIdUseEnumType["ManufacturerRootCertificate"] = "ManufacturerRootCertificate";
    GetCertificateIdUseEnumType["OEMRootCertificate"] = "OEMRootCertificate";
})(GetCertificateIdUseEnumType || (GetCertificateIdUseEnumType = {}));
/**
 * Indicates where the measured value has been sampled. Default =  "Outlet"
 *
 *
 */
export var LocationEnumType;
(function (LocationEnumType) {
    LocationEnumType["Body"] = "Body";
    LocationEnumType["Cable"] = "Cable";
    LocationEnumType["EV"] = "EV";
    LocationEnumType["Inlet"] = "Inlet";
    LocationEnumType["Outlet"] = "Outlet";
    LocationEnumType["Upstream"] = "Upstream";
})(LocationEnumType || (LocationEnumType = {}));
/**
 * Indicates whether the Charging Station was able to accept the request.
 *
 */
export var GenericDeviceModelStatusEnumType;
(function (GenericDeviceModelStatusEnumType) {
    GenericDeviceModelStatusEnumType["Accepted"] = "Accepted";
    GenericDeviceModelStatusEnumType["Rejected"] = "Rejected";
    GenericDeviceModelStatusEnumType["NotSupported"] = "NotSupported";
    GenericDeviceModelStatusEnumType["EmptyResultSet"] = "EmptyResultSet";
})(GenericDeviceModelStatusEnumType || (GenericDeviceModelStatusEnumType = {}));
/**
 * Indicates whether the Charging Station will send the requested notification or not.
 *
 */
export var TriggerMessageStatusEnumType;
(function (TriggerMessageStatusEnumType) {
    TriggerMessageStatusEnumType["Accepted"] = "Accepted";
    TriggerMessageStatusEnumType["Rejected"] = "Rejected";
    TriggerMessageStatusEnumType["NotImplemented"] = "NotImplemented";
})(TriggerMessageStatusEnumType || (TriggerMessageStatusEnumType = {}));
/**
 * Indicates whether the Local Controller succeeded in unpublishing the firmware.
 *
 */
export var UnpublishFirmwareStatusEnumType;
(function (UnpublishFirmwareStatusEnumType) {
    UnpublishFirmwareStatusEnumType["DownloadOngoing"] = "DownloadOngoing";
    UnpublishFirmwareStatusEnumType["NoFirmware"] = "NoFirmware";
    UnpublishFirmwareStatusEnumType["Unpublished"] = "Unpublished";
})(UnpublishFirmwareStatusEnumType || (UnpublishFirmwareStatusEnumType = {}));
/**
 * Indicates whether the message was processed properly.
 *
 */
export var Iso15118EVCertificateStatusEnumType;
(function (Iso15118EVCertificateStatusEnumType) {
    Iso15118EVCertificateStatusEnumType["Accepted"] = "Accepted";
    Iso15118EVCertificateStatusEnumType["Failed"] = "Failed";
})(Iso15118EVCertificateStatusEnumType || (Iso15118EVCertificateStatusEnumType = {}));
/**
 * Indicates whether the request was accepted.
 *
 */
export var CustomerInformationStatusEnumType;
(function (CustomerInformationStatusEnumType) {
    CustomerInformationStatusEnumType["Accepted"] = "Accepted";
    CustomerInformationStatusEnumType["Rejected"] = "Rejected";
    CustomerInformationStatusEnumType["Invalid"] = "Invalid";
})(CustomerInformationStatusEnumType || (CustomerInformationStatusEnumType = {}));
/**
 * Kind of tariff (driver/default)
 *
 */
export var TariffKindEnumType;
(function (TariffKindEnumType) {
    TariffKindEnumType["DefaultTariff"] = "DefaultTariff";
    TariffKindEnumType["DriverTariff"] = "DriverTariff";
})(TariffKindEnumType || (TariffKindEnumType = {}));
/**
 * Mode of energy transfer requested by the EV.
 *
 */
export var EnergyTransferModeEnumType;
(function (EnergyTransferModeEnumType) {
    EnergyTransferModeEnumType["AC_single_phase"] = "AC_single_phase";
    EnergyTransferModeEnumType["AC_two_phase"] = "AC_two_phase";
    EnergyTransferModeEnumType["AC_three_phase"] = "AC_three_phase";
    EnergyTransferModeEnumType["DC"] = "DC";
    EnergyTransferModeEnumType["AC_BPT"] = "AC_BPT";
    EnergyTransferModeEnumType["AC_BPT_DER"] = "AC_BPT_DER";
    EnergyTransferModeEnumType["AC_DER"] = "AC_DER";
    EnergyTransferModeEnumType["DC_BPT"] = "DC_BPT";
    EnergyTransferModeEnumType["DC_ACDP"] = "DC_ACDP";
    EnergyTransferModeEnumType["DC_ACDP_BPT"] = "DC_ACDP_BPT";
    EnergyTransferModeEnumType["WPT"] = "WPT";
})(EnergyTransferModeEnumType || (EnergyTransferModeEnumType = {}));
/**
 * Parameter is only sent, if the EV has to feed-in power or reactive power during fault-ride through (FRT) as defined by HVMomCess curve and LVMomCess curve.
 *
 *
 *
 */
export var PowerDuringCessationEnumType;
(function (PowerDuringCessationEnumType) {
    PowerDuringCessationEnumType["Active"] = "Active";
    PowerDuringCessationEnumType["Reactive"] = "Reactive";
})(PowerDuringCessationEnumType || (PowerDuringCessationEnumType = {}));
/**
 * Reason the Charging Station sends this message to the CSMS
 *
 */
export var TriggerReasonEnumType;
(function (TriggerReasonEnumType) {
    TriggerReasonEnumType["AbnormalCondition"] = "AbnormalCondition";
    TriggerReasonEnumType["Authorized"] = "Authorized";
    TriggerReasonEnumType["CablePluggedIn"] = "CablePluggedIn";
    TriggerReasonEnumType["ChargingRateChanged"] = "ChargingRateChanged";
    TriggerReasonEnumType["ChargingStateChanged"] = "ChargingStateChanged";
    TriggerReasonEnumType["CostLimitReached"] = "CostLimitReached";
    TriggerReasonEnumType["Deauthorized"] = "Deauthorized";
    TriggerReasonEnumType["EnergyLimitReached"] = "EnergyLimitReached";
    TriggerReasonEnumType["EVCommunicationLost"] = "EVCommunicationLost";
    TriggerReasonEnumType["EVConnectTimeout"] = "EVConnectTimeout";
    TriggerReasonEnumType["EVDeparted"] = "EVDeparted";
    TriggerReasonEnumType["EVDetected"] = "EVDetected";
    TriggerReasonEnumType["LimitSet"] = "LimitSet";
    TriggerReasonEnumType["MeterValueClock"] = "MeterValueClock";
    TriggerReasonEnumType["MeterValuePeriodic"] = "MeterValuePeriodic";
    TriggerReasonEnumType["OperationModeChanged"] = "OperationModeChanged";
    TriggerReasonEnumType["RemoteStart"] = "RemoteStart";
    TriggerReasonEnumType["RemoteStop"] = "RemoteStop";
    TriggerReasonEnumType["ResetCommand"] = "ResetCommand";
    TriggerReasonEnumType["RunningCost"] = "RunningCost";
    TriggerReasonEnumType["SignedDataReceived"] = "SignedDataReceived";
    TriggerReasonEnumType["SoCLimitReached"] = "SoCLimitReached";
    TriggerReasonEnumType["StopAuthorized"] = "StopAuthorized";
    TriggerReasonEnumType["TariffChanged"] = "TariffChanged";
    TriggerReasonEnumType["TariffNotAccepted"] = "TariffNotAccepted";
    TriggerReasonEnumType["TimeLimitReached"] = "TimeLimitReached";
    TriggerReasonEnumType["Trigger"] = "Trigger";
    TriggerReasonEnumType["TxResumed"] = "TxResumed";
    TriggerReasonEnumType["UnlockCommand"] = "UnlockCommand";
})(TriggerReasonEnumType || (TriggerReasonEnumType = {}));
/**
 * Result of operation.
 *
 *
 */
export var DERControlStatusEnumType;
(function (DERControlStatusEnumType) {
    DERControlStatusEnumType["Accepted"] = "Accepted";
    DERControlStatusEnumType["Rejected"] = "Rejected";
    DERControlStatusEnumType["NotSupported"] = "NotSupported";
    DERControlStatusEnumType["NotFound"] = "NotFound";
})(DERControlStatusEnumType || (DERControlStatusEnumType = {}));
/**
 * Result of operation.
 *
 */
export var GenericStatusEnumType;
(function (GenericStatusEnumType) {
    GenericStatusEnumType["Accepted"] = "Accepted";
    GenericStatusEnumType["Rejected"] = "Rejected";
})(GenericStatusEnumType || (GenericStatusEnumType = {}));
/**
 * Result of operation.
 *
 */
export var SetNetworkProfileStatusEnumType;
(function (SetNetworkProfileStatusEnumType) {
    SetNetworkProfileStatusEnumType["Accepted"] = "Accepted";
    SetNetworkProfileStatusEnumType["Rejected"] = "Rejected";
    SetNetworkProfileStatusEnumType["Failed"] = "Failed";
})(SetNetworkProfileStatusEnumType || (SetNetworkProfileStatusEnumType = {}));
/**
 * Result of the clear request for this monitor, identified by its Id.
 *
 *
 */
export var ClearMonitoringStatusEnumType;
(function (ClearMonitoringStatusEnumType) {
    ClearMonitoringStatusEnumType["Accepted"] = "Accepted";
    ClearMonitoringStatusEnumType["Rejected"] = "Rejected";
    ClearMonitoringStatusEnumType["NotFound"] = "NotFound";
})(ClearMonitoringStatusEnumType || (ClearMonitoringStatusEnumType = {}));
/**
 * Result of the request.
 *
 */
export var PriorityChargingStatusEnumType;
(function (PriorityChargingStatusEnumType) {
    PriorityChargingStatusEnumType["Accepted"] = "Accepted";
    PriorityChargingStatusEnumType["Rejected"] = "Rejected";
    PriorityChargingStatusEnumType["NoProfile"] = "NoProfile";
})(PriorityChargingStatusEnumType || (PriorityChargingStatusEnumType = {}));
/**
 * Result status of setting the variable.
 *
 */
export var SetVariableStatusEnumType;
(function (SetVariableStatusEnumType) {
    SetVariableStatusEnumType["Accepted"] = "Accepted";
    SetVariableStatusEnumType["Rejected"] = "Rejected";
    SetVariableStatusEnumType["UnknownComponent"] = "UnknownComponent";
    SetVariableStatusEnumType["UnknownVariable"] = "UnknownVariable";
    SetVariableStatusEnumType["NotSupportedAttributeType"] = "NotSupportedAttributeType";
    SetVariableStatusEnumType["RebootRequired"] = "RebootRequired";
})(SetVariableStatusEnumType || (SetVariableStatusEnumType = {}));
/**
 * Returns whether certificate signing has been accepted, otherwise rejected.
 *
 */
export var CertificateSignedStatusEnumType;
(function (CertificateSignedStatusEnumType) {
    CertificateSignedStatusEnumType["Accepted"] = "Accepted";
    CertificateSignedStatusEnumType["Rejected"] = "Rejected";
})(CertificateSignedStatusEnumType || (CertificateSignedStatusEnumType = {}));
/**
 * Returns whether message was processed successfully.
 *
 */
export var ChargingProfileStatusEnumType;
(function (ChargingProfileStatusEnumType) {
    ChargingProfileStatusEnumType["Accepted"] = "Accepted";
    ChargingProfileStatusEnumType["Rejected"] = "Rejected";
})(ChargingProfileStatusEnumType || (ChargingProfileStatusEnumType = {}));
/**
 * Returns whether the CSMS has been able to process the message successfully. It does not imply that the evChargingNeeds can be met with the current charging profile.
 *
 */
export var NotifyEVChargingNeedsStatusEnumType;
(function (NotifyEVChargingNeedsStatusEnumType) {
    NotifyEVChargingNeedsStatusEnumType["Accepted"] = "Accepted";
    NotifyEVChargingNeedsStatusEnumType["Rejected"] = "Rejected";
    NotifyEVChargingNeedsStatusEnumType["Processing"] = "Processing";
    NotifyEVChargingNeedsStatusEnumType["NoChargingProfile"] = "NoChargingProfile";
})(NotifyEVChargingNeedsStatusEnumType || (NotifyEVChargingNeedsStatusEnumType = {}));
/**
 * Returns whether the Charging Station has been able to remove the message.
 *
 */
export var ClearMessageStatusEnumType;
(function (ClearMessageStatusEnumType) {
    ClearMessageStatusEnumType["Accepted"] = "Accepted";
    ClearMessageStatusEnumType["Unknown"] = "Unknown";
    ClearMessageStatusEnumType["Rejected"] = "Rejected";
})(ClearMessageStatusEnumType || (ClearMessageStatusEnumType = {}));
/**
 * Source of status: OCSP, CRL
 *
 */
export var CertificateStatusSourceEnumType;
(function (CertificateStatusSourceEnumType) {
    CertificateStatusSourceEnumType["CRL"] = "CRL";
    CertificateStatusSourceEnumType["OCSP"] = "OCSP";
})(CertificateStatusSourceEnumType || (CertificateStatusSourceEnumType = {}));
/**
 * Specify which monitoring base will be set
 *
 */
export var MonitoringBaseEnumType;
(function (MonitoringBaseEnumType) {
    MonitoringBaseEnumType["All"] = "All";
    MonitoringBaseEnumType["FactoryDefault"] = "FactoryDefault";
    MonitoringBaseEnumType["HardWiredOnly"] = "HardWiredOnly";
})(MonitoringBaseEnumType || (MonitoringBaseEnumType = {}));
/**
 * Status indicating whether Charging Station accepts the request to stop a transaction.
 *
 */
export var RequestStartStopStatusEnumType;
(function (RequestStartStopStatusEnumType) {
    RequestStartStopStatusEnumType["Accepted"] = "Accepted";
    RequestStartStopStatusEnumType["Rejected"] = "Rejected";
})(RequestStartStopStatusEnumType || (RequestStartStopStatusEnumType = {}));
/**
 * Status is OK if a value could be returned. Otherwise this will indicate the reason why a value could not be returned.
 *
 */
export var SetMonitoringStatusEnumType;
(function (SetMonitoringStatusEnumType) {
    SetMonitoringStatusEnumType["Accepted"] = "Accepted";
    SetMonitoringStatusEnumType["UnknownComponent"] = "UnknownComponent";
    SetMonitoringStatusEnumType["UnknownVariable"] = "UnknownVariable";
    SetMonitoringStatusEnumType["UnsupportedMonitorType"] = "UnsupportedMonitorType";
    SetMonitoringStatusEnumType["Rejected"] = "Rejected";
    SetMonitoringStatusEnumType["Duplicate"] = "Duplicate";
})(SetMonitoringStatusEnumType || (SetMonitoringStatusEnumType = {}));
/**
 * Status of certificate: good, revoked or unknown.
 *
 */
export var CertificateStatusEnumType;
(function (CertificateStatusEnumType) {
    CertificateStatusEnumType["Good"] = "Good";
    CertificateStatusEnumType["Revoked"] = "Revoked";
    CertificateStatusEnumType["Unknown"] = "Unknown";
    CertificateStatusEnumType["Failed"] = "Failed";
})(CertificateStatusEnumType || (CertificateStatusEnumType = {}));
/**
 * Status of operation
 *
 */
export var TariffGetStatusEnumType;
(function (TariffGetStatusEnumType) {
    TariffGetStatusEnumType["Accepted"] = "Accepted";
    TariffGetStatusEnumType["Rejected"] = "Rejected";
    TariffGetStatusEnumType["NoTariff"] = "NoTariff";
})(TariffGetStatusEnumType || (TariffGetStatusEnumType = {}));
/**
 * Status of the operation
 *
 */
export var TariffChangeStatusEnumType;
(function (TariffChangeStatusEnumType) {
    TariffChangeStatusEnumType["Accepted"] = "Accepted";
    TariffChangeStatusEnumType["Rejected"] = "Rejected";
    TariffChangeStatusEnumType["TooManyElements"] = "TooManyElements";
    TariffChangeStatusEnumType["ConditionNotSupported"] = "ConditionNotSupported";
    TariffChangeStatusEnumType["TxNotFound"] = "TxNotFound";
    TariffChangeStatusEnumType["NoCurrencyChange"] = "NoCurrencyChange";
})(TariffChangeStatusEnumType || (TariffChangeStatusEnumType = {}));
/**
 * The _stoppedReason_ is the reason/event that initiated the process of stopping the transaction. It will normally be the user stopping authorization via card (Local or MasterPass) or app (Remote), but it can also be CSMS revoking authorization (DeAuthorized), or disconnecting the EV when TxStopPoint = EVConnected (EVDisconnected). Most other reasons are related to technical faults or energy limitations. +
 * MAY only be omitted when _stoppedReason_ is "Local"
 *
 *
 *
 */
export var ReasonEnumType;
(function (ReasonEnumType) {
    ReasonEnumType["DeAuthorized"] = "DeAuthorized";
    ReasonEnumType["EmergencyStop"] = "EmergencyStop";
    ReasonEnumType["EnergyLimitReached"] = "EnergyLimitReached";
    ReasonEnumType["EVDisconnected"] = "EVDisconnected";
    ReasonEnumType["GroundFault"] = "GroundFault";
    ReasonEnumType["ImmediateReset"] = "ImmediateReset";
    ReasonEnumType["MasterPass"] = "MasterPass";
    ReasonEnumType["Local"] = "Local";
    ReasonEnumType["LocalOutOfCredit"] = "LocalOutOfCredit";
    ReasonEnumType["Other"] = "Other";
    ReasonEnumType["OvercurrentFault"] = "OvercurrentFault";
    ReasonEnumType["PowerLoss"] = "PowerLoss";
    ReasonEnumType["PowerQuality"] = "PowerQuality";
    ReasonEnumType["Reboot"] = "Reboot";
    ReasonEnumType["Remote"] = "Remote";
    ReasonEnumType["SOCLimitReached"] = "SOCLimitReached";
    ReasonEnumType["StoppedByEV"] = "StoppedByEV";
    ReasonEnumType["TimeLimitReached"] = "TimeLimitReached";
    ReasonEnumType["Timeout"] = "Timeout";
    ReasonEnumType["ReqEnergyTransferRejected"] = "ReqEnergyTransferRejected";
})(ReasonEnumType || (ReasonEnumType = {}));
/**
 * The kind of cost referred to in the message element amount
 *
 */
export var CostKindEnumType;
(function (CostKindEnumType) {
    CostKindEnumType["CarbonDioxideEmission"] = "CarbonDioxideEmission";
    CostKindEnumType["RelativePricePercentage"] = "RelativePricePercentage";
    CostKindEnumType["RenewableGenerationPercentage"] = "RenewableGenerationPercentage";
})(CostKindEnumType || (CostKindEnumType = {}));
/**
 * The status of the settlement attempt.
 *
 *
 */
export var PaymentStatusEnumType;
(function (PaymentStatusEnumType) {
    PaymentStatusEnumType["Settled"] = "Settled";
    PaymentStatusEnumType["Canceled"] = "Canceled";
    PaymentStatusEnumType["Rejected"] = "Rejected";
    PaymentStatusEnumType["Failed"] = "Failed";
})(PaymentStatusEnumType || (PaymentStatusEnumType = {}));
/**
 * The type of this monitor, e.g. a threshold, delta or periodic monitor.
 *
 *
 */
export var MonitorEnumType;
(function (MonitorEnumType) {
    MonitorEnumType["UpperThreshold"] = "UpperThreshold";
    MonitorEnumType["LowerThreshold"] = "LowerThreshold";
    MonitorEnumType["Delta"] = "Delta";
    MonitorEnumType["Periodic"] = "Periodic";
    MonitorEnumType["PeriodicClockAligned"] = "PeriodicClockAligned";
    MonitorEnumType["TargetDelta"] = "TargetDelta";
    MonitorEnumType["TargetDeltaRelative"] = "TargetDeltaRelative";
})(MonitorEnumType || (MonitorEnumType = {}));
/**
 * The unit of measure in which limits and setpoints are expressed.
 *
 */
export var ChargingRateUnitEnumType;
(function (ChargingRateUnitEnumType) {
    ChargingRateUnitEnumType["W"] = "W";
    ChargingRateUnitEnumType["A"] = "A";
})(ChargingRateUnitEnumType || (ChargingRateUnitEnumType = {}));
/**
 * The updated reservation status.
 *
 */
export var ReservationUpdateStatusEnumType;
(function (ReservationUpdateStatusEnumType) {
    ReservationUpdateStatusEnumType["Expired"] = "Expired";
    ReservationUpdateStatusEnumType["Removed"] = "Removed";
    ReservationUpdateStatusEnumType["NoTransaction"] = "NoTransaction";
})(ReservationUpdateStatusEnumType || (ReservationUpdateStatusEnumType = {}));
/**
 * This contains the current status of the Connector.
 *
 */
export var ConnectorStatusEnumType;
(function (ConnectorStatusEnumType) {
    ConnectorStatusEnumType["Available"] = "Available";
    ConnectorStatusEnumType["Occupied"] = "Occupied";
    ConnectorStatusEnumType["Reserved"] = "Reserved";
    ConnectorStatusEnumType["Unavailable"] = "Unavailable";
    ConnectorStatusEnumType["Faulted"] = "Faulted";
})(ConnectorStatusEnumType || (ConnectorStatusEnumType = {}));
/**
 * This contains the progress status of the firmware installation.
 *
 */
export var FirmwareStatusEnumType;
(function (FirmwareStatusEnumType) {
    FirmwareStatusEnumType["Downloaded"] = "Downloaded";
    FirmwareStatusEnumType["DownloadFailed"] = "DownloadFailed";
    FirmwareStatusEnumType["Downloading"] = "Downloading";
    FirmwareStatusEnumType["DownloadScheduled"] = "DownloadScheduled";
    FirmwareStatusEnumType["DownloadPaused"] = "DownloadPaused";
    FirmwareStatusEnumType["Idle"] = "Idle";
    FirmwareStatusEnumType["InstallationFailed"] = "InstallationFailed";
    FirmwareStatusEnumType["Installing"] = "Installing";
    FirmwareStatusEnumType["Installed"] = "Installed";
    FirmwareStatusEnumType["InstallRebooting"] = "InstallRebooting";
    FirmwareStatusEnumType["InstallScheduled"] = "InstallScheduled";
    FirmwareStatusEnumType["InstallVerificationFailed"] = "InstallVerificationFailed";
    FirmwareStatusEnumType["InvalidSignature"] = "InvalidSignature";
    FirmwareStatusEnumType["SignatureVerified"] = "SignatureVerified";
})(FirmwareStatusEnumType || (FirmwareStatusEnumType = {}));
/**
 * This contains the progress status of the publishfirmware
 * installation.
 *
 */
export var PublishFirmwareStatusEnumType;
(function (PublishFirmwareStatusEnumType) {
    PublishFirmwareStatusEnumType["Idle"] = "Idle";
    PublishFirmwareStatusEnumType["DownloadScheduled"] = "DownloadScheduled";
    PublishFirmwareStatusEnumType["Downloading"] = "Downloading";
    PublishFirmwareStatusEnumType["Downloaded"] = "Downloaded";
    PublishFirmwareStatusEnumType["Published"] = "Published";
    PublishFirmwareStatusEnumType["DownloadFailed"] = "DownloadFailed";
    PublishFirmwareStatusEnumType["DownloadPaused"] = "DownloadPaused";
    PublishFirmwareStatusEnumType["InvalidChecksum"] = "InvalidChecksum";
    PublishFirmwareStatusEnumType["ChecksumVerified"] = "ChecksumVerified";
    PublishFirmwareStatusEnumType["PublishFailed"] = "PublishFailed";
})(PublishFirmwareStatusEnumType || (PublishFirmwareStatusEnumType = {}));
/**
 * This contains the reason for sending this message to the CSMS.
 *
 */
export var BootReasonEnumType;
(function (BootReasonEnumType) {
    BootReasonEnumType["ApplicationReset"] = "ApplicationReset";
    BootReasonEnumType["FirmwareUpdate"] = "FirmwareUpdate";
    BootReasonEnumType["LocalReset"] = "LocalReset";
    BootReasonEnumType["PowerUp"] = "PowerUp";
    BootReasonEnumType["RemoteReset"] = "RemoteReset";
    BootReasonEnumType["ScheduledReset"] = "ScheduledReset";
    BootReasonEnumType["Triggered"] = "Triggered";
    BootReasonEnumType["Unknown"] = "Unknown";
    BootReasonEnumType["Watchdog"] = "Watchdog";
})(BootReasonEnumType || (BootReasonEnumType = {}));
/**
 * This contains the status of the log upload.
 *
 */
export var UploadLogStatusEnumType;
(function (UploadLogStatusEnumType) {
    UploadLogStatusEnumType["BadMessage"] = "BadMessage";
    UploadLogStatusEnumType["Idle"] = "Idle";
    UploadLogStatusEnumType["NotSupportedOperation"] = "NotSupportedOperation";
    UploadLogStatusEnumType["PermissionDenied"] = "PermissionDenied";
    UploadLogStatusEnumType["Uploaded"] = "Uploaded";
    UploadLogStatusEnumType["UploadFailure"] = "UploadFailure";
    UploadLogStatusEnumType["Uploading"] = "Uploading";
    UploadLogStatusEnumType["AcceptedCanceled"] = "AcceptedCanceled";
})(UploadLogStatusEnumType || (UploadLogStatusEnumType = {}));
/**
 * This contains the type of availability change that the Charging Station should perform.
 *
 *
 */
export var OperationalStatusEnumType;
(function (OperationalStatusEnumType) {
    OperationalStatusEnumType["Inoperative"] = "Inoperative";
    OperationalStatusEnumType["Operative"] = "Operative";
})(OperationalStatusEnumType || (OperationalStatusEnumType = {}));
/**
 * This contains the type of log file that the Charging Station
 * should send.
 *
 */
export var LogEnumType;
(function (LogEnumType) {
    LogEnumType["DiagnosticsLog"] = "DiagnosticsLog";
    LogEnumType["SecurityLog"] = "SecurityLog";
    LogEnumType["DataCollectorLog"] = "DataCollectorLog";
})(LogEnumType || (LogEnumType = {}));
/**
 * This contains the type of reset that the Charging Station or EVSE should perform.
 *
 */
export var ResetEnumType;
(function (ResetEnumType) {
    ResetEnumType["Immediate"] = "Immediate";
    ResetEnumType["OnIdle"] = "OnIdle";
    ResetEnumType["ImmediateAndResume"] = "ImmediateAndResume";
})(ResetEnumType || (ResetEnumType = {}));
/**
 * This contains the type of this event.
 * The first TransactionEvent of a transaction SHALL contain: "Started" The last TransactionEvent of a transaction SHALL contain: "Ended" All others SHALL contain: "Updated"
 *
 */
export var TransactionEventEnumType;
(function (TransactionEventEnumType) {
    TransactionEventEnumType["Ended"] = "Ended";
    TransactionEventEnumType["Started"] = "Started";
    TransactionEventEnumType["Updated"] = "Updated";
})(TransactionEventEnumType || (TransactionEventEnumType = {}));
/**
 * This contains the type of update (full or differential) of this request.
 *
 */
export var UpdateEnumType;
(function (UpdateEnumType) {
    UpdateEnumType["Differential"] = "Differential";
    UpdateEnumType["Full"] = "Full";
})(UpdateEnumType || (UpdateEnumType = {}));
/**
 * This contains whether the Charging Station has been registered
 * within the CSMS.
 *
 */
export var RegistrationStatusEnumType;
(function (RegistrationStatusEnumType) {
    RegistrationStatusEnumType["Accepted"] = "Accepted";
    RegistrationStatusEnumType["Pending"] = "Pending";
    RegistrationStatusEnumType["Rejected"] = "Rejected";
})(RegistrationStatusEnumType || (RegistrationStatusEnumType = {}));
/**
 * This field indicates whether the Charging Station was able to accept the request.
 *
 *
 */
export var UpdateFirmwareStatusEnumType;
(function (UpdateFirmwareStatusEnumType) {
    UpdateFirmwareStatusEnumType["Accepted"] = "Accepted";
    UpdateFirmwareStatusEnumType["Rejected"] = "Rejected";
    UpdateFirmwareStatusEnumType["AcceptedCanceled"] = "AcceptedCanceled";
    UpdateFirmwareStatusEnumType["InvalidCertificate"] = "InvalidCertificate";
    UpdateFirmwareStatusEnumType["RevokedCertificate"] = "RevokedCertificate";
})(UpdateFirmwareStatusEnumType || (UpdateFirmwareStatusEnumType = {}));
/**
 * This field indicates whether the Charging Station was able to accept the request.
 *
 */
export var LogStatusEnumType;
(function (LogStatusEnumType) {
    LogStatusEnumType["Accepted"] = "Accepted";
    LogStatusEnumType["Rejected"] = "Rejected";
    LogStatusEnumType["AcceptedCanceled"] = "AcceptedCanceled";
})(LogStatusEnumType || (LogStatusEnumType = {}));
/**
 * This field specifies the report base.
 *
 */
export var ReportBaseEnumType;
(function (ReportBaseEnumType) {
    ReportBaseEnumType["ConfigurationInventory"] = "ConfigurationInventory";
    ReportBaseEnumType["FullInventory"] = "FullInventory";
    ReportBaseEnumType["SummaryInventory"] = "SummaryInventory";
})(ReportBaseEnumType || (ReportBaseEnumType = {}));
/**
 * This indicates the success or failure of the canceling of a reservation by CSMS.
 *
 */
export var CancelReservationStatusEnumType;
(function (CancelReservationStatusEnumType) {
    CancelReservationStatusEnumType["Accepted"] = "Accepted";
    CancelReservationStatusEnumType["Rejected"] = "Rejected";
})(CancelReservationStatusEnumType || (CancelReservationStatusEnumType = {}));
/**
 * This indicates the success or failure of the data transfer.
 *
 */
export var DataTransferStatusEnumType;
(function (DataTransferStatusEnumType) {
    DataTransferStatusEnumType["Accepted"] = "Accepted";
    DataTransferStatusEnumType["Rejected"] = "Rejected";
    DataTransferStatusEnumType["UnknownMessageId"] = "UnknownMessageId";
    DataTransferStatusEnumType["UnknownVendorId"] = "UnknownVendorId";
})(DataTransferStatusEnumType || (DataTransferStatusEnumType = {}));
/**
 * This indicates the success or failure of the reservation.
 *
 */
export var ReserveNowStatusEnumType;
(function (ReserveNowStatusEnumType) {
    ReserveNowStatusEnumType["Accepted"] = "Accepted";
    ReserveNowStatusEnumType["Faulted"] = "Faulted";
    ReserveNowStatusEnumType["Occupied"] = "Occupied";
    ReserveNowStatusEnumType["Rejected"] = "Rejected";
    ReserveNowStatusEnumType["Unavailable"] = "Unavailable";
})(ReserveNowStatusEnumType || (ReserveNowStatusEnumType = {}));
/**
 * This indicates whether the Charging Station has successfully received and applied the update of the Local Authorization List.
 *
 */
export var SendLocalListStatusEnumType;
(function (SendLocalListStatusEnumType) {
    SendLocalListStatusEnumType["Accepted"] = "Accepted";
    SendLocalListStatusEnumType["Failed"] = "Failed";
    SendLocalListStatusEnumType["VersionMismatch"] = "VersionMismatch";
})(SendLocalListStatusEnumType || (SendLocalListStatusEnumType = {}));
/**
 * This indicates whether the Charging Station has unlocked the connector.
 *
 */
export var UnlockStatusEnumType;
(function (UnlockStatusEnumType) {
    UnlockStatusEnumType["Unlocked"] = "Unlocked";
    UnlockStatusEnumType["UnlockFailed"] = "UnlockFailed";
    UnlockStatusEnumType["OngoingAuthorizedTransaction"] = "OngoingAuthorizedTransaction";
    UnlockStatusEnumType["UnknownConnector"] = "UnknownConnector";
})(UnlockStatusEnumType || (UnlockStatusEnumType = {}));
/**
 * This indicates whether the Charging Station is able to display the message.
 *
 */
export var DisplayMessageStatusEnumType;
(function (DisplayMessageStatusEnumType) {
    DisplayMessageStatusEnumType["Accepted"] = "Accepted";
    DisplayMessageStatusEnumType["NotSupportedMessageFormat"] = "NotSupportedMessageFormat";
    DisplayMessageStatusEnumType["Rejected"] = "Rejected";
    DisplayMessageStatusEnumType["NotSupportedPriority"] = "NotSupportedPriority";
    DisplayMessageStatusEnumType["NotSupportedState"] = "NotSupportedState";
    DisplayMessageStatusEnumType["UnknownTransaction"] = "UnknownTransaction";
    DisplayMessageStatusEnumType["LanguageNotSupported"] = "LanguageNotSupported";
})(DisplayMessageStatusEnumType || (DisplayMessageStatusEnumType = {}));
/**
 * This indicates whether the Charging Station is able to perform the availability change.
 *
 */
export var ChangeAvailabilityStatusEnumType;
(function (ChangeAvailabilityStatusEnumType) {
    ChangeAvailabilityStatusEnumType["Accepted"] = "Accepted";
    ChangeAvailabilityStatusEnumType["Rejected"] = "Rejected";
    ChangeAvailabilityStatusEnumType["Scheduled"] = "Scheduled";
})(ChangeAvailabilityStatusEnumType || (ChangeAvailabilityStatusEnumType = {}));
/**
 * This indicates whether the Charging Station is able to perform the reset.
 *
 */
export var ResetStatusEnumType;
(function (ResetStatusEnumType) {
    ResetStatusEnumType["Accepted"] = "Accepted";
    ResetStatusEnumType["Rejected"] = "Rejected";
    ResetStatusEnumType["Scheduled"] = "Scheduled";
})(ResetStatusEnumType || (ResetStatusEnumType = {}));
/**
 * This indicates whether the Charging Station is able to process this request and will send <<reportchargingprofilesrequest, ReportChargingProfilesRequest>> messages.
 *
 */
export var GetChargingProfileStatusEnumType;
(function (GetChargingProfileStatusEnumType) {
    GetChargingProfileStatusEnumType["Accepted"] = "Accepted";
    GetChargingProfileStatusEnumType["NoProfiles"] = "NoProfiles";
})(GetChargingProfileStatusEnumType || (GetChargingProfileStatusEnumType = {}));
/**
 * This indicates whether the charging station was able to retrieve the OCSP certificate status.
 *
 */
export var GetCertificateStatusEnumType;
(function (GetCertificateStatusEnumType) {
    GetCertificateStatusEnumType["Accepted"] = "Accepted";
    GetCertificateStatusEnumType["Failed"] = "Failed";
})(GetCertificateStatusEnumType || (GetCertificateStatusEnumType = {}));
/**
 * Type of EVSE (AC, DC) this tariff applies to.
 *
 */
export var EvseKindEnumType;
(function (EvseKindEnumType) {
    EvseKindEnumType["AC"] = "AC";
    EvseKindEnumType["DC"] = "DC";
})(EvseKindEnumType || (EvseKindEnumType = {}));
/**
 * Type of VPN
 *
 */
export var VPNEnumType;
(function (VPNEnumType) {
    VPNEnumType["IKEv2"] = "IKEv2";
    VPNEnumType["IPSec"] = "IPSec";
    VPNEnumType["L2TP"] = "L2TP";
    VPNEnumType["PPTP"] = "PPTP";
})(VPNEnumType || (VPNEnumType = {}));
/**
 * Type of attribute: Actual, Target, MinSet, MaxSet. Default is Actual when omitted.
 *
 */
export var AttributeEnumType;
(function (AttributeEnumType) {
    AttributeEnumType["Actual"] = "Actual";
    AttributeEnumType["Target"] = "Target";
    AttributeEnumType["MinSet"] = "MinSet";
    AttributeEnumType["MaxSet"] = "MaxSet";
})(AttributeEnumType || (AttributeEnumType = {}));
/**
 * Type of control.  Determines which setting field below is used.
 *
 *
 */
export var DERControlEnumType;
(function (DERControlEnumType) {
    DERControlEnumType["EnterService"] = "EnterService";
    DERControlEnumType["FreqDroop"] = "FreqDroop";
    DERControlEnumType["FreqWatt"] = "FreqWatt";
    DERControlEnumType["FixedPFAbsorb"] = "FixedPFAbsorb";
    DERControlEnumType["FixedPFInject"] = "FixedPFInject";
    DERControlEnumType["FixedVar"] = "FixedVar";
    DERControlEnumType["Gradients"] = "Gradients";
    DERControlEnumType["HFMustTrip"] = "HFMustTrip";
    DERControlEnumType["HFMayTrip"] = "HFMayTrip";
    DERControlEnumType["HVMustTrip"] = "HVMustTrip";
    DERControlEnumType["HVMomCess"] = "HVMomCess";
    DERControlEnumType["HVMayTrip"] = "HVMayTrip";
    DERControlEnumType["LimitMaxDischarge"] = "LimitMaxDischarge";
    DERControlEnumType["LFMustTrip"] = "LFMustTrip";
    DERControlEnumType["LVMustTrip"] = "LVMustTrip";
    DERControlEnumType["LVMomCess"] = "LVMomCess";
    DERControlEnumType["LVMayTrip"] = "LVMayTrip";
    DERControlEnumType["PowerMonitoringMustTrip"] = "PowerMonitoringMustTrip";
    DERControlEnumType["VoltVar"] = "VoltVar";
    DERControlEnumType["VoltWatt"] = "VoltWatt";
    DERControlEnumType["WattPF"] = "WattPF";
    DERControlEnumType["WattVar"] = "WattVar";
})(DERControlEnumType || (DERControlEnumType = {}));
/**
 * Type of cost dimension: energy, power, time, etc.
 *
 *
 */
export var CostDimensionEnumType;
(function (CostDimensionEnumType) {
    CostDimensionEnumType["Energy"] = "Energy";
    CostDimensionEnumType["MaxCurrent"] = "MaxCurrent";
    CostDimensionEnumType["MinCurrent"] = "MinCurrent";
    CostDimensionEnumType["MaxPower"] = "MaxPower";
    CostDimensionEnumType["MinPower"] = "MinPower";
    CostDimensionEnumType["IdleTIme"] = "IdleTIme";
    CostDime