ocpp_types.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
// This code is generated using the generator in 'src/code_generator/common`, please do not edit manually
 
#ifndef OCPP_V2_OCPP_TYPES_HPP
#define OCPP_V2_OCPP_TYPES_HPP
 
#include <string>
 
#include <nlohmann/json_fwd.hpp>
#include <optional>
 
#include <ocpp/common/types.hpp>
#include <ocpp/v2/ocpp_enums.hpp>
 
namespace ocpp {
namespace v2 {
 
using CustomData = nlohmann::json;
 
struct AdditionalInfo {
    CiString<36> additionalIdToken;
    CiString<50> type;
    std::optional<CustomData> customData;
};
void to_json(json& j, const AdditionalInfo& k);
 
void from_json(const json& j, AdditionalInfo& k);
 
// \brief Writes the string representation of the given AdditionalInfo \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const AdditionalInfo& k);
 
struct IdToken {
    CiString<36> idToken;
    IdTokenEnum type;
    std::optional<CustomData> customData;
    std::optional<std::vector<AdditionalInfo>> additionalInfo;
};
void to_json(json& j, const IdToken& k);
 
void from_json(const json& j, IdToken& k);
 
// \brief Writes the string representation of the given IdToken \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const IdToken& k);
 
struct OCSPRequestData {
    HashAlgorithmEnum hashAlgorithm;
    CiString<128> issuerNameHash;
    CiString<128> issuerKeyHash;
    CiString<40> serialNumber;
    CiString<512> responderURL;
    std::optional<CustomData> customData;
};
void to_json(json& j, const OCSPRequestData& k);
 
void from_json(const json& j, OCSPRequestData& k);
 
// \brief Writes the string representation of the given OCSPRequestData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const OCSPRequestData& k);
 
struct MessageContent {
    MessageFormatEnum format;
    CiString<512> content;
    std::optional<CustomData> customData;
    std::optional<CiString<8>> language;
};
void to_json(json& j, const MessageContent& k);
 
void from_json(const json& j, MessageContent& k);
 
// \brief Writes the string representation of the given MessageContent \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const MessageContent& k);
 
struct IdTokenInfo {
    AuthorizationStatusEnum status;
    std::optional<CustomData> customData;
    std::optional<ocpp::DateTime> cacheExpiryDateTime;
    std::optional<int32_t> chargingPriority;
    std::optional<CiString<8>> language1;
    std::optional<std::vector<int32_t>> evseId;
    std::optional<IdToken> groupIdToken;
    std::optional<CiString<8>> language2;
    std::optional<MessageContent> personalMessage;
};
void to_json(json& j, const IdTokenInfo& k);
 
void from_json(const json& j, IdTokenInfo& k);
 
// \brief Writes the string representation of the given IdTokenInfo \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const IdTokenInfo& k);
 
struct Modem {
    std::optional<CustomData> customData;
    std::optional<CiString<20>> iccid;
    std::optional<CiString<20>> imsi;
};
void to_json(json& j, const Modem& k);
 
void from_json(const json& j, Modem& k);
 
// \brief Writes the string representation of the given Modem \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const Modem& k);
 
struct ChargingStation {
    CiString<20> model;
    CiString<50> vendorName;
    std::optional<CustomData> customData;
    std::optional<CiString<25>> serialNumber;
    std::optional<Modem> modem;
    std::optional<CiString<50>> firmwareVersion;
};
void to_json(json& j, const ChargingStation& k);
 
void from_json(const json& j, ChargingStation& k);
 
// \brief Writes the string representation of the given ChargingStation \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingStation& k);
 
struct StatusInfo {
    CiString<20> reasonCode;
    std::optional<CustomData> customData;
    std::optional<CiString<512>> additionalInfo;
};
void to_json(json& j, const StatusInfo& k);
 
void from_json(const json& j, StatusInfo& k);
 
// \brief Writes the string representation of the given StatusInfo \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const StatusInfo& k);
 
struct EVSE {
    int32_t id;
    std::optional<CustomData> customData;
    std::optional<int32_t> connectorId;
};
void to_json(json& j, const EVSE& k);
 
void from_json(const json& j, EVSE& k);
 
// \brief Writes the string representation of the given EVSE \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const EVSE& k);
 
struct ClearChargingProfile {
    std::optional<CustomData> customData;
    std::optional<int32_t> evseId;
    std::optional<ChargingProfilePurposeEnum> chargingProfilePurpose;
    std::optional<int32_t> stackLevel;
};
void to_json(json& j, const ClearChargingProfile& k);
 
void from_json(const json& j, ClearChargingProfile& k);
 
// \brief Writes the string representation of the given ClearChargingProfile \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ClearChargingProfile& k);
 
struct ClearMonitoringResult {
    ClearMonitoringStatusEnum status;
    int32_t id;
    std::optional<CustomData> customData;
    std::optional<StatusInfo> statusInfo;
};
void to_json(json& j, const ClearMonitoringResult& k);
 
void from_json(const json& j, ClearMonitoringResult& k);
 
// \brief Writes the string representation of the given ClearMonitoringResult \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ClearMonitoringResult& k);
 
struct CertificateHashDataType {
    HashAlgorithmEnum hashAlgorithm;
    CiString<128> issuerNameHash;
    CiString<128> issuerKeyHash;
    CiString<40> serialNumber;
    std::optional<CustomData> customData;
};
void to_json(json& j, const CertificateHashDataType& k);
 
void from_json(const json& j, CertificateHashDataType& k);
 
// \brief Writes the string representation of the given CertificateHashDataType \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const CertificateHashDataType& k);
 
struct ChargingProfileCriterion {
    std::optional<CustomData> customData;
    std::optional<ChargingProfilePurposeEnum> chargingProfilePurpose;
    std::optional<int32_t> stackLevel;
    std::optional<std::vector<int32_t>> chargingProfileId;
    std::optional<std::vector<ChargingLimitSourceEnum>> chargingLimitSource;
};
void to_json(json& j, const ChargingProfileCriterion& k);
 
void from_json(const json& j, ChargingProfileCriterion& k);
 
// \brief Writes the string representation of the given ChargingProfileCriterion \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingProfileCriterion& k);
 
struct ChargingSchedulePeriod {
    int32_t startPeriod;
    float limit;
    std::optional<CustomData> customData;
    std::optional<int32_t> numberPhases;
    std::optional<int32_t> phaseToUse;
};
void to_json(json& j, const ChargingSchedulePeriod& k);
 
void from_json(const json& j, ChargingSchedulePeriod& k);
 
// \brief Writes the string representation of the given ChargingSchedulePeriod \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingSchedulePeriod& k);
 
struct CompositeSchedule {
    std::vector<ChargingSchedulePeriod> chargingSchedulePeriod;
    int32_t evseId;
    int32_t duration;
    ocpp::DateTime scheduleStart;
    ChargingRateUnitEnum chargingRateUnit;
    std::optional<CustomData> customData;
};
void to_json(json& j, const CompositeSchedule& k);
 
void from_json(const json& j, CompositeSchedule& k);
 
// \brief Writes the string representation of the given CompositeSchedule \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const CompositeSchedule& k);
 
struct CertificateHashDataChain {
    CertificateHashDataType certificateHashData;
    GetCertificateIdUseEnum certificateType;
    std::optional<CustomData> customData;
    std::optional<std::vector<CertificateHashDataType>> childCertificateHashData;
};
void to_json(json& j, const CertificateHashDataChain& k);
 
void from_json(const json& j, CertificateHashDataChain& k);
 
// \brief Writes the string representation of the given CertificateHashDataChain \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const CertificateHashDataChain& k);
 
struct LogParameters {
    CiString<512> remoteLocation;
    std::optional<CustomData> customData;
    std::optional<ocpp::DateTime> oldestTimestamp;
    std::optional<ocpp::DateTime> latestTimestamp;
};
void to_json(json& j, const LogParameters& k);
 
void from_json(const json& j, LogParameters& k);
 
// \brief Writes the string representation of the given LogParameters \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const LogParameters& k);
 
struct Component {
    CiString<50> name;
    std::optional<CustomData> customData;
    std::optional<EVSE> evse;
    std::optional<CiString<50>> instance;
};
void to_json(json& j, const Component& k);
 
void from_json(const json& j, Component& k);
 
// \brief Writes the string representation of the given Component \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const Component& k);
 
struct Variable {
    CiString<50> name;
    std::optional<CustomData> customData;
    std::optional<CiString<50>> instance;
};
void to_json(json& j, const Variable& k);
 
void from_json(const json& j, Variable& k);
 
// \brief Writes the string representation of the given Variable \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const Variable& k);
 
struct ComponentVariable {
    Component component;
    std::optional<CustomData> customData;
    std::optional<Variable> variable;
};
void to_json(json& j, const ComponentVariable& k);
 
void from_json(const json& j, ComponentVariable& k);
 
// \brief Writes the string representation of the given ComponentVariable \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ComponentVariable& k);
 
struct GetVariableData {
    Component component;
    Variable variable;
    std::optional<CustomData> customData;
    std::optional<AttributeEnum> attributeType;
};
void to_json(json& j, const GetVariableData& k);
 
void from_json(const json& j, GetVariableData& k);
 
// \brief Writes the string representation of the given GetVariableData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const GetVariableData& k);
 
struct GetVariableResult {
    GetVariableStatusEnum attributeStatus;
    Component component;
    Variable variable;
    std::optional<CustomData> customData;
    std::optional<StatusInfo> attributeStatusInfo;
    std::optional<AttributeEnum> attributeType;
    std::optional<CiString<2500>> attributeValue;
};
void to_json(json& j, const GetVariableResult& k);
 
void from_json(const json& j, GetVariableResult& k);
 
// \brief Writes the string representation of the given GetVariableResult \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const GetVariableResult& k);
 
struct SignedMeterValue {
    CiString<2500> signedMeterData;
    CiString<50> signingMethod;
    CiString<50> encodingMethod;
    CiString<2500> publicKey;
    std::optional<CustomData> customData;
};
void to_json(json& j, const SignedMeterValue& k);
 
void from_json(const json& j, SignedMeterValue& k);
 
// \brief Writes the string representation of the given SignedMeterValue \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SignedMeterValue& k);
 
struct UnitOfMeasure {
    std::optional<CustomData> customData;
    std::optional<CiString<20>> unit;
    std::optional<int32_t> multiplier;
};
void to_json(json& j, const UnitOfMeasure& k);
 
void from_json(const json& j, UnitOfMeasure& k);
 
// \brief Writes the string representation of the given UnitOfMeasure \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const UnitOfMeasure& k);
 
struct SampledValue {
    float value;
    std::optional<CustomData> customData;
    std::optional<ReadingContextEnum> context;
    std::optional<MeasurandEnum> measurand;
    std::optional<PhaseEnum> phase;
    std::optional<LocationEnum> location;
    std::optional<SignedMeterValue> signedMeterValue;
    std::optional<UnitOfMeasure> unitOfMeasure;
};
void to_json(json& j, const SampledValue& k);
 
void from_json(const json& j, SampledValue& k);
 
// \brief Writes the string representation of the given SampledValue \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SampledValue& k);
 
struct MeterValue {
    std::vector<SampledValue> sampledValue;
    ocpp::DateTime timestamp;
    std::optional<CustomData> customData;
};
void to_json(json& j, const MeterValue& k);
 
void from_json(const json& j, MeterValue& k);
 
// \brief Writes the string representation of the given MeterValue \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const MeterValue& k);
 
struct RelativeTimeInterval {
    int32_t start;
    std::optional<CustomData> customData;
    std::optional<int32_t> duration;
};
void to_json(json& j, const RelativeTimeInterval& k);
 
void from_json(const json& j, RelativeTimeInterval& k);
 
// \brief Writes the string representation of the given RelativeTimeInterval \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const RelativeTimeInterval& k);
 
struct Cost {
    CostKindEnum costKind;
    int32_t amount;
    std::optional<CustomData> customData;
    std::optional<int32_t> amountMultiplier;
};
void to_json(json& j, const Cost& k);
 
void from_json(const json& j, Cost& k);
 
// \brief Writes the string representation of the given Cost \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const Cost& k);
 
struct ConsumptionCost {
    float startValue;
    std::vector<Cost> cost;
    std::optional<CustomData> customData;
};
void to_json(json& j, const ConsumptionCost& k);
 
void from_json(const json& j, ConsumptionCost& k);
 
// \brief Writes the string representation of the given ConsumptionCost \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ConsumptionCost& k);
 
struct SalesTariffEntry {
    RelativeTimeInterval relativeTimeInterval;
    std::optional<CustomData> customData;
    std::optional<int32_t> ePriceLevel;
    std::optional<std::vector<ConsumptionCost>> consumptionCost;
};
void to_json(json& j, const SalesTariffEntry& k);
 
void from_json(const json& j, SalesTariffEntry& k);
 
// \brief Writes the string representation of the given SalesTariffEntry \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SalesTariffEntry& k);
 
struct SalesTariff {
    int32_t id;
    std::vector<SalesTariffEntry> salesTariffEntry;
    std::optional<CustomData> customData;
    std::optional<CiString<32>> salesTariffDescription;
    std::optional<int32_t> numEPriceLevels;
};
void to_json(json& j, const SalesTariff& k);
 
void from_json(const json& j, SalesTariff& k);
 
// \brief Writes the string representation of the given SalesTariff \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SalesTariff& k);
 
struct ChargingSchedule {
    int32_t id;
    ChargingRateUnitEnum chargingRateUnit;
    std::vector<ChargingSchedulePeriod> chargingSchedulePeriod;
    std::optional<CustomData> customData;
    std::optional<ocpp::DateTime> startSchedule;
    std::optional<int32_t> duration;
    std::optional<float> minChargingRate;
    std::optional<SalesTariff> salesTariff;
};
void to_json(json& j, const ChargingSchedule& k);
 
void from_json(const json& j, ChargingSchedule& k);
 
// \brief Writes the string representation of the given ChargingSchedule \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingSchedule& k);
 
struct ChargingLimit {
    ChargingLimitSourceEnum chargingLimitSource;
    std::optional<CustomData> customData;
    std::optional<bool> isGridCritical;
};
void to_json(json& j, const ChargingLimit& k);
 
void from_json(const json& j, ChargingLimit& k);
 
// \brief Writes the string representation of the given ChargingLimit \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingLimit& k);
 
struct MessageInfo {
    int32_t id;
    MessagePriorityEnum priority;
    MessageContent message;
    std::optional<CustomData> customData;
    std::optional<Component> display;
    std::optional<MessageStateEnum> state;
    std::optional<ocpp::DateTime> startDateTime;
    std::optional<ocpp::DateTime> endDateTime;
    std::optional<CiString<36>> transactionId;
};
void to_json(json& j, const MessageInfo& k);
 
void from_json(const json& j, MessageInfo& k);
 
// \brief Writes the string representation of the given MessageInfo \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const MessageInfo& k);
 
struct ACChargingParameters {
    int32_t energyAmount;
    int32_t evMinCurrent;
    int32_t evMaxCurrent;
    int32_t evMaxVoltage;
    std::optional<CustomData> customData;
};
void to_json(json& j, const ACChargingParameters& k);
 
void from_json(const json& j, ACChargingParameters& k);
 
// \brief Writes the string representation of the given ACChargingParameters \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ACChargingParameters& k);
 
struct DCChargingParameters {
    int32_t evMaxCurrent;
    int32_t evMaxVoltage;
    std::optional<CustomData> customData;
    std::optional<int32_t> energyAmount;
    std::optional<int32_t> evMaxPower;
    std::optional<int32_t> stateOfCharge;
    std::optional<int32_t> evEnergyCapacity;
    std::optional<int32_t> fullSoC;
    std::optional<int32_t> bulkSoC;
};
void to_json(json& j, const DCChargingParameters& k);
 
void from_json(const json& j, DCChargingParameters& k);
 
// \brief Writes the string representation of the given DCChargingParameters \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const DCChargingParameters& k);
 
struct ChargingNeeds {
    EnergyTransferModeEnum requestedEnergyTransfer;
    std::optional<CustomData> customData;
    std::optional<ACChargingParameters> acChargingParameters;
    std::optional<DCChargingParameters> dcChargingParameters;
    std::optional<ocpp::DateTime> departureTime;
};
void to_json(json& j, const ChargingNeeds& k);
 
void from_json(const json& j, ChargingNeeds& k);
 
// \brief Writes the string representation of the given ChargingNeeds \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingNeeds& k);
 
struct EventData {
    int32_t eventId;
    ocpp::DateTime timestamp;
    EventTriggerEnum trigger;
    CiString<2500> actualValue;
    Component component;
    EventNotificationEnum eventNotificationType;
    Variable variable;
    std::optional<CustomData> customData;
    std::optional<int32_t> cause;
    std::optional<CiString<50>> techCode;
    std::optional<CiString<500>> techInfo;
    std::optional<bool> cleared;
    std::optional<CiString<36>> transactionId;
    std::optional<int32_t> variableMonitoringId;
};
void to_json(json& j, const EventData& k);
 
void from_json(const json& j, EventData& k);
 
// \brief Writes the string representation of the given EventData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const EventData& k);
 
struct VariableMonitoring {
    int32_t id;
    bool transaction;
    float value;
    MonitorEnum type;
    int32_t severity;
    std::optional<CustomData> customData;
};
void to_json(json& j, const VariableMonitoring& k);
 
void from_json(const json& j, VariableMonitoring& k);
 
// \brief Writes the string representation of the given VariableMonitoring \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const VariableMonitoring& k);
 
struct MonitoringData {
    Component component;
    Variable variable;
    std::vector<VariableMonitoring> variableMonitoring;
    std::optional<CustomData> customData;
};
void to_json(json& j, const MonitoringData& k);
 
void from_json(const json& j, MonitoringData& k);
 
// \brief Writes the string representation of the given MonitoringData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const MonitoringData& k);
 
struct VariableAttribute {
    std::optional<CustomData> customData;
    std::optional<AttributeEnum> type;
    std::optional<CiString<2500>> value;
    std::optional<MutabilityEnum> mutability;
    std::optional<bool> persistent;
    std::optional<bool> constant;
};
void to_json(json& j, const VariableAttribute& k);
 
void from_json(const json& j, VariableAttribute& k);
 
// \brief Writes the string representation of the given VariableAttribute \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const VariableAttribute& k);
 
struct VariableCharacteristics {
    DataEnum dataType;
    bool supportsMonitoring;
    std::optional<CustomData> customData;
    std::optional<CiString<16>> unit;
    std::optional<float> minLimit;
    std::optional<float> maxLimit;
    std::optional<CiString<1000>> valuesList;
};
void to_json(json& j, const VariableCharacteristics& k);
 
void from_json(const json& j, VariableCharacteristics& k);
 
// \brief Writes the string representation of the given VariableCharacteristics \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const VariableCharacteristics& k);
 
struct ReportData {
    Component component;
    Variable variable;
    std::vector<VariableAttribute> variableAttribute;
    std::optional<CustomData> customData;
    std::optional<VariableCharacteristics> variableCharacteristics;
};
void to_json(json& j, const ReportData& k);
 
void from_json(const json& j, ReportData& k);
 
// \brief Writes the string representation of the given ReportData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ReportData& k);
 
struct ChargingProfile {
    int32_t id;
    int32_t stackLevel;
    ChargingProfilePurposeEnum chargingProfilePurpose;
    ChargingProfileKindEnum chargingProfileKind;
    std::vector<ChargingSchedule> chargingSchedule;
    std::optional<CustomData> customData;
    std::optional<RecurrencyKindEnum> recurrencyKind;
    std::optional<ocpp::DateTime> validFrom;
    std::optional<ocpp::DateTime> validTo;
    std::optional<CiString<36>> transactionId;
};
void to_json(json& j, const ChargingProfile& k);
 
void from_json(const json& j, ChargingProfile& k);
 
// \brief Writes the string representation of the given ChargingProfile \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const ChargingProfile& k);
 
struct AuthorizationData {
    IdToken idToken;
    std::optional<CustomData> customData;
    std::optional<IdTokenInfo> idTokenInfo;
};
void to_json(json& j, const AuthorizationData& k);
 
void from_json(const json& j, AuthorizationData& k);
 
// \brief Writes the string representation of the given AuthorizationData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const AuthorizationData& k);
 
struct APN {
    CiString<512> apn;
    APNAuthenticationEnum apnAuthentication;
    std::optional<CustomData> customData;
    std::optional<CiString<20>> apnUserName;
    std::optional<CiString<20>> apnPassword;
    std::optional<int32_t> simPin;
    std::optional<CiString<6>> preferredNetwork;
    std::optional<bool> useOnlyPreferredNetwork;
};
void to_json(json& j, const APN& k);
 
void from_json(const json& j, APN& k);
 
// \brief Writes the string representation of the given APN \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const APN& k);
 
struct VPN {
    CiString<512> server;
    CiString<20> user;
    CiString<20> password;
    CiString<255> key;
    VPNEnum type;
    std::optional<CustomData> customData;
    std::optional<CiString<20>> group;
};
void to_json(json& j, const VPN& k);
 
void from_json(const json& j, VPN& k);
 
// \brief Writes the string representation of the given VPN \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const VPN& k);
 
struct NetworkConnectionProfile {
    OCPPVersionEnum ocppVersion;
    OCPPTransportEnum ocppTransport;
    CiString<512> ocppCsmsUrl;
    int32_t messageTimeout;
    int32_t securityProfile;
    OCPPInterfaceEnum ocppInterface;
    std::optional<CustomData> customData;
    std::optional<APN> apn;
    std::optional<VPN> vpn;
};
void to_json(json& j, const NetworkConnectionProfile& k);
 
void from_json(const json& j, NetworkConnectionProfile& k);
 
// \brief Writes the string representation of the given NetworkConnectionProfile \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const NetworkConnectionProfile& k);
 
struct SetMonitoringData {
    float value;
    MonitorEnum type;
    int32_t severity;
    Component component;
    Variable variable;
    std::optional<CustomData> customData;
    std::optional<int32_t> id;
    std::optional<bool> transaction;
};
void to_json(json& j, const SetMonitoringData& k);
 
void from_json(const json& j, SetMonitoringData& k);
 
// \brief Writes the string representation of the given SetMonitoringData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SetMonitoringData& k);
 
struct SetMonitoringResult {
    SetMonitoringStatusEnum status;
    MonitorEnum type;
    Component component;
    Variable variable;
    int32_t severity;
    std::optional<CustomData> customData;
    std::optional<int32_t> id;
    std::optional<StatusInfo> statusInfo;
};
void to_json(json& j, const SetMonitoringResult& k);
 
void from_json(const json& j, SetMonitoringResult& k);
 
// \brief Writes the string representation of the given SetMonitoringResult \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SetMonitoringResult& k);
 
struct ConfigNetworkResult {
    std::optional<std::string> interface_address; 
    bool success;                                 
};
 
struct SetVariableData {
    CiString<1000> attributeValue;
    Component component;
    Variable variable;
    std::optional<CustomData> customData;
    std::optional<AttributeEnum> attributeType;
};
void to_json(json& j, const SetVariableData& k);
 
void from_json(const json& j, SetVariableData& k);
 
// \brief Writes the string representation of the given SetVariableData \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SetVariableData& k);
 
struct SetVariableResult {
    SetVariableStatusEnum attributeStatus;
    Component component;
    Variable variable;
    std::optional<CustomData> customData;
    std::optional<AttributeEnum> attributeType;
    std::optional<StatusInfo> attributeStatusInfo;
};
void to_json(json& j, const SetVariableResult& k);
 
void from_json(const json& j, SetVariableResult& k);
 
// \brief Writes the string representation of the given SetVariableResult \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const SetVariableResult& k);
 
struct Transaction {
    CiString<36> transactionId;
    std::optional<CustomData> customData;
    std::optional<ChargingStateEnum> chargingState;
    std::optional<int32_t> timeSpentCharging;
    std::optional<ReasonEnum> stoppedReason;
    std::optional<int32_t> remoteStartId;
};
void to_json(json& j, const Transaction& k);
 
void from_json(const json& j, Transaction& k);
 
// \brief Writes the string representation of the given Transaction \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const Transaction& k);
 
struct Firmware {
    CiString<512> location;
    ocpp::DateTime retrieveDateTime;
    std::optional<CustomData> customData;
    std::optional<ocpp::DateTime> installDateTime;
    std::optional<CiString<5500>> signingCertificate;
    std::optional<CiString<800>> signature;
};
void to_json(json& j, const Firmware& k);
 
void from_json(const json& j, Firmware& k);
 
// \brief Writes the string representation of the given Firmware \p k to the given output stream \p os
std::ostream& operator<<(std::ostream& os, const Firmware& k);
 
struct RequiredComponentVariable : ComponentVariable {};
} // namespace v2
} // namespace ocpp
 
#endif // OCPP_V2_OCPP_TYPES_HPP