dss_classic.hpp

 
#pragma once
#ifndef DSS_CPP_CLASSIC_API
#define DSS_CPP_CLASSIC_API
 
#include "dss_common.hpp"
#include "dss_obj.hpp"
 
namespace dss { namespace classic {
 
#ifdef DSS_CAPI_NAMESPACE
using namespace dss::capi;
#endif
 
 
 
    class IDSSProgress: public ContextState
    {
    public:
 
        IDSSProgress(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        void Close()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProgress_Close(ctx);
        }
        void Show()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProgress_Show(ctx);
        }
 
        IDSSProgress& Caption(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProgress_Set_Caption(ctx, value);
            return *this;
        }
        IDSSProgress& Caption(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProgress_Set_Caption(ctx, value.c_str());
            return *this;
        }
 
        IDSSProgress& PctProgress(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProgress_Set_PctProgress(ctx, value);
            return *this;
        }
    };
 
    class IDSSProperty: public ContextState
    {
    public:
 
        IDSSProperty(dss::APIUtil *util) :
            ContextState(util)
        {
        }
    
        IDSSProperty& operator[](int32_t key) // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProperty_Set_Index(ctx, key);
            return *this;
        }
 
        IDSSProperty& operator[](const char *key) // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProperty_Set_Name(ctx, key);
            return *this;
        }
        IDSSProperty& operator[](const string &key) // getter
        {
            return (*this)[key.c_str()];
        }
 
        string Description() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSSProperty_Get_Description(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSSProperty_Get_Name(ctx);
        }
 
        string Val() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSSProperty_Get_Val(ctx);
        }
        IDSSProperty& Val(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProperty_Set_Val(ctx, value);
            return *this;
        }
        IDSSProperty& Val(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSProperty_Set_Val(ctx, value.c_str());
            return *this;
        }
    };
 
    class IDSS_Executive: public ContextState
    {
    public:
 
        IDSS_Executive(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        string Command(int32_t i)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_Command(ctx, i);
        }
        string CommandHelp(int32_t i)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_CommandHelp(ctx, i);
        }
        string Option(int32_t i)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_Option(ctx, i);
        }
        string OptionHelp(int32_t i)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_OptionHelp(ctx, i);
        }
        string OptionValue(int32_t i)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_OptionValue(ctx, i);
        }
 
        int32_t NumCommands() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_NumCommands(ctx);
        }
 
        int32_t NumOptions() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Executive_Get_NumOptions(ctx);
        }
    };
 
    class IDSSimComs: public ContextState
    {
    public:
 
        IDSSimComs(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT BusVoltage(size_t Index)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSimComs_BusVoltage_GR(ctx, Index);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT BusVoltagepu(size_t Index)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSSimComs_BusVoltagepu_GR(ctx, Index);
            return api_util->get_float64_gr_array<VectorT>();
        }
    };
 
    class IError: public ContextState
    {
    public:
 
        IError(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        string Description() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Error_Get_Description(ctx);
        }
 
        int32_t Number() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Error_Get_Number(ctx);
        }
 
        bool EarlyAbort() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Error_Get_EarlyAbort(ctx) != 0);
        }
        IError& EarlyAbort(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Error_Set_EarlyAbort(ctx, value);
            return *this;
        }
 
        bool ExtendedErrors() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Error_Get_ExtendedErrors(ctx) != 0);
        }
        IError& ExtendedErrors(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Error_Set_ExtendedErrors(ctx, value);
            return *this;
        }
    };
 
    class IFuses: public ContextState
    {
    public:
 
        IFuses(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Fuses_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_Name(ctx);
        }
 
        IFuses& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_Name(ctx, value);
            return *this;
        }
        IFuses& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_idx(ctx, value);
        }
        void Close()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Close(ctx);
        }
        bool IsBlown()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Fuses_IsBlown(ctx) != 0);
        }
        void Open()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Open(ctx);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Reset(ctx);
        }
 
        double Delay() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_Delay(ctx);
        }
        IFuses& Delay(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_Delay(ctx, value);
            return *this;
        }
 
        string MonitoredObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_MonitoredObj(ctx);
        }
        IFuses& MonitoredObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_MonitoredObj(ctx, value);
            return *this;
        }
        IFuses& MonitoredObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_MonitoredObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t MonitoredTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_MonitoredTerm(ctx);
        }
        IFuses& MonitoredTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_MonitoredTerm(ctx, value);
            return *this;
        }
 
        int32_t NumPhases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_NumPhases(ctx);
        }
 
        double RatedCurrent() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_RatedCurrent(ctx);
        }
        IFuses& RatedCurrent(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_RatedCurrent(ctx, value);
            return *this;
        }
 
        string SwitchedObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_SwitchedObj(ctx);
        }
        IFuses& SwitchedObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_SwitchedObj(ctx, value);
            return *this;
        }
        IFuses& SwitchedObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_SwitchedObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t SwitchedTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_SwitchedTerm(ctx);
        }
        IFuses& SwitchedTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_SwitchedTerm(ctx, value);
            return *this;
        }
 
        string TCCcurve() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Fuses_Get_TCCcurve(ctx);
        }
        IFuses& TCCcurve(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_TCCcurve(ctx, value);
            return *this;
        }
        IFuses& TCCcurve(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Fuses_Set_TCCcurve(ctx, value.c_str());
            return *this;
        }
 
        strings State() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Fuses_Get_State);
        }
        IFuses& State(const strings &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            api_util->set_string_array(ctx_Fuses_Set_State, value);
            return *this;
        }
 
        strings NormalState() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Fuses_Get_NormalState);
        }
        IFuses& NormalState(const strings &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            api_util->set_string_array(ctx_Fuses_Set_NormalState, value);
            return *this;
        }
    };
 
    class IGenerators: public ContextState
    {
    public:
 
        IGenerators(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Generators_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Name(ctx);
        }
 
        IGenerators& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Name(ctx, value);
            return *this;
        }
        IGenerators& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_idx(ctx, value);
        }
 
        bool ForcedON() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Generators_Get_ForcedON(ctx) != 0);
        }
        IGenerators& ForcedON(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_ForcedON(ctx, value);
            return *this;
        }
 
        int32_t Model() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Model(ctx);
        }
        IGenerators& Model(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Model(ctx, value);
            return *this;
        }
 
        double PF() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_PF(ctx);
        }
        IGenerators& PF(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_PF(ctx, value);
            return *this;
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Phases(ctx);
        }
        IGenerators& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Phases(ctx, value);
            return *this;
        }
 
        strings RegisterNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Generators_Get_RegisterNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT RegisterValues() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Get_RegisterValues_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double Vmaxpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Vmaxpu(ctx);
        }
        IGenerators& Vmaxpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Vmaxpu(ctx, value);
            return *this;
        }
 
        double Vminpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Vminpu(ctx);
        }
        IGenerators& Vminpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Vminpu(ctx, value);
            return *this;
        }
 
        double kV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_kV(ctx);
        }
        IGenerators& kV(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_kV(ctx, value);
            return *this;
        }
 
        double kVArated() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_kVArated(ctx);
        }
        IGenerators& kVArated(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_kVArated(ctx, value);
            return *this;
        }
 
        double kW() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_kW(ctx);
        }
        IGenerators& kW(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_kW(ctx, value);
            return *this;
        }
 
        double kvar() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_kvar(ctx);
        }
        IGenerators& kvar(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_kvar(ctx, value);
            return *this;
        }
 
        string daily() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_daily(ctx);
        }
        IGenerators& daily(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_daily(ctx, value);
            return *this;
        }
        IGenerators& daily(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_daily(ctx, value.c_str());
            return *this;
        }
 
        string duty() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_duty(ctx);
        }
        IGenerators& duty(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_duty(ctx, value);
            return *this;
        }
        IGenerators& duty(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_duty(ctx, value.c_str());
            return *this;
        }
 
        string Yearly() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Yearly(ctx);
        }
        IGenerators& Yearly(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Yearly(ctx, value);
            return *this;
        }
        IGenerators& Yearly(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Yearly(ctx, value.c_str());
            return *this;
        }
 
        int32_t Status() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Status(ctx);
        }
        IGenerators& Status(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Status(ctx, value);
            return *this;
        }
 
        bool IsDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Generators_Get_IsDelta(ctx) != 0);
        }
        IGenerators& IsDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_IsDelta(ctx, value);
            return *this;
        }
 
        double kva() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_kva(ctx);
        }
        IGenerators& kva(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_kva(ctx, value);
            return *this;
        }
 
        int32_t Class() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Class_(ctx);
        }
        IGenerators& Class(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Class_(ctx, value);
            return *this;
        }
 
        string Bus1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Generators_Get_Bus1(ctx);
        }
        IGenerators& Bus1(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Bus1(ctx, value);
            return *this;
        }
        IGenerators& Bus1(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Generators_Set_Bus1(ctx, value.c_str());
            return *this;
        }
    };
 
    class IISources: public ContextState
    {
    public:
 
        IISources(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_ISources_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_Name(ctx);
        }
 
        IISources& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ISources_Set_Name(ctx, value);
            return *this;
        }
        IISources& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ISources_Set_idx(ctx, value);
        }
 
        double Amps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_Amps(ctx);
        }
        IISources& Amps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ISources_Set_Amps(ctx, value);
            return *this;
        }
 
        double AngleDeg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_AngleDeg(ctx);
        }
        IISources& AngleDeg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ISources_Set_AngleDeg(ctx, value);
            return *this;
        }
 
        double Frequency() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ISources_Get_Frequency(ctx);
        }
        IISources& Frequency(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ISources_Set_Frequency(ctx, value);
            return *this;
        }
    };
 
    class ILineCodes: public ContextState
    {
    public:
 
        ILineCodes(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_LineCodes_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_Name(ctx);
        }
 
        ILineCodes& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_Name(ctx, value);
            return *this;
        }
        ILineCodes& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_idx(ctx, value);
        }
 
        double C0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_C0(ctx);
        }
        ILineCodes& C0(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_C0(ctx, value);
            return *this;
        }
 
        double C1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_C1(ctx);
        }
        ILineCodes& C1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_C1(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Cmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Get_Cmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineCodes& Cmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_Cmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_EmergAmps(ctx);
        }
        ILineCodes& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        bool IsZ1Z0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_LineCodes_Get_IsZ1Z0(ctx) != 0);
        }
 
        double NormAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_NormAmps(ctx);
        }
        ILineCodes& NormAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_NormAmps(ctx, value);
            return *this;
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_Phases(ctx);
        }
        ILineCodes& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_Phases(ctx, value);
            return *this;
        }
 
        double R0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_R0(ctx);
        }
        ILineCodes& R0(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_R0(ctx, value);
            return *this;
        }
 
        double R1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_R1(ctx);
        }
        ILineCodes& R1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_R1(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Rmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Get_Rmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineCodes& Rmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_Rmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        int32_t Units() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_Units(ctx);
        }
        ILineCodes& Units(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_Units(ctx, value);
            return *this;
        }
 
        double X0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_X0(ctx);
        }
        ILineCodes& X0(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_X0(ctx, value);
            return *this;
        }
 
        double X1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineCodes_Get_X1(ctx);
        }
        ILineCodes& X1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_X1(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Get_Xmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineCodes& Xmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineCodes_Set_Xmatrix(ctx, &value[0], value.size());
            return *this;
        }
    };
 
    class ILineSpacings: public ContextState
    {
    public:
 
        ILineSpacings(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_LineSpacings_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_Name(ctx);
        }
 
        ILineSpacings& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_Name(ctx, value);
            return *this;
        }
        ILineSpacings& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_idx(ctx, value);
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_Phases(ctx);
        }
        ILineSpacings& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_Phases(ctx, value);
            return *this;
        }
 
        int32_t Nconds() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_Nconds(ctx);
        }
        ILineSpacings& Nconds(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_Nconds(ctx, value);
            return *this;
        }
 
        int32_t Units() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineSpacings_Get_Units(ctx);
        }
        ILineSpacings& Units(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_Units(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xcoords() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Get_Xcoords_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineSpacings& Xcoords(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_Xcoords(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Ycoords() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Get_Ycoords_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineSpacings& Ycoords(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineSpacings_Set_Ycoords(ctx, &value[0], value.size());
            return *this;
        }
    };
 
    class ILoadShapes: public ContextState
    {
    public:
 
        ILoadShapes(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_LoadShapes_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_Name(ctx);
        }
 
        ILoadShapes& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_Name(ctx, value);
            return *this;
        }
        ILoadShapes& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_idx(ctx, value);
        }
        int32_t New(const char *Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_New(ctx, Name);
        }
        int32_t New(const string &Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_New(ctx, Name.c_str());
        }
        void Normalize()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Normalize(ctx);
        }
 
        double HrInterval() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_HrInterval(ctx);
        }
        ILoadShapes& HrInterval(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_HrInterval(ctx, value);
            return *this;
        }
 
        double MinInterval() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_MinInterval(ctx);
        }
        ILoadShapes& MinInterval(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_MinInterval(ctx, value);
            return *this;
        }
 
        int32_t Npts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_Npts(ctx);
        }
        ILoadShapes& Npts(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_Npts(ctx, value);
            return *this;
        }
 
        double PBase() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_PBase(ctx);
        }
        ILoadShapes& PBase(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_PBase(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Pmult() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Get_Pmult_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILoadShapes& Pmult(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_Pmult(ctx, &value[0], value.size());
            return *this;
        }
 
        double QBase() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_Qbase(ctx);
        }
        ILoadShapes& QBase(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_Qbase(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Qmult() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Get_Qmult_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILoadShapes& Qmult(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_Qmult(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT TimeArray() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Get_TimeArray_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILoadShapes& TimeArray(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_TimeArray(ctx, &value[0], value.size());
            return *this;
        }
 
        bool UseActual() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_LoadShapes_Get_UseActual(ctx) != 0);
        }
        ILoadShapes& UseActual(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_UseActual(ctx, value);
            return *this;
        }
 
        double sInterval() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LoadShapes_Get_SInterval(ctx);
        }
        ILoadShapes& sInterval(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_Set_SInterval(ctx, value);
            return *this;
        }
        void UseFloat32()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_UseFloat32(ctx);
        }
        void UseFloat64()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LoadShapes_UseFloat64(ctx);
        }
    };
 
    class IMonitors: public ContextState
    {
    public:
 
        IMonitors(dss::APIUtil *util) :
            ContextState(util)
        {
        }
    
        // TODO: Implement AsMatrix someday
 
        template <typename VectorT=Eigen::VectorXd>
        VectorT Channel(int32_t Index)
        {
            //TODO: use the better implementation
            ctx_Monitors_Get_Channel_GR(ctx, Index);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Monitors_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_Name(ctx);
        }
 
        IMonitors& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Set_Name(ctx, value);
            return *this;
        }
        IMonitors& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Set_idx(ctx, value);
        }
        void Process()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Process(ctx);
        }
        void ProcessAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_ProcessAll(ctx);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Reset(ctx);
        }
        void ResetAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_ResetAll(ctx);
        }
        void Sample()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Sample(ctx);
        }
        void SampleAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_SampleAll(ctx);
        }
        void Save()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Save(ctx);
        }
        void SaveAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_SaveAll(ctx);
        }
        void Show()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Show(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<int8_t, Eigen::Dynamic, 1>>
        VectorT ByteStream() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Get_ByteStream_GR(ctx);
            return api_util->get_int8_gr_array<VectorT>();
        }
 
        string Element() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_Element(ctx);
        }
        IMonitors& Element(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Set_Element(ctx, value);
            return *this;
        }
        IMonitors& Element(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Set_Element(ctx, value.c_str());
            return *this;
        }
 
        string FileName() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_FileName(ctx);
        }
 
        int32_t FileVersion() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_FileVersion(ctx);
        }
 
        strings Header() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Monitors_Get_Header);
        }
 
        int32_t Mode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_Mode(ctx);
        }
        IMonitors& Mode(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Set_Mode(ctx, value);
            return *this;
        }
 
        int32_t NumChannels() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_NumChannels(ctx);
        }
 
        int32_t RecordSize() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_RecordSize(ctx);
        }
 
        int32_t SampleCount() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_SampleCount(ctx);
        }
 
        int32_t Terminal() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Monitors_Get_Terminal(ctx);
        }
        IMonitors& Terminal(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Set_Terminal(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT dblFreq() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Get_dblFreq_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT dblHour() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Monitors_Get_dblHour_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
    };
 
    class IParser: public ContextState
    {
    public:
 
        IParser(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Matrix(int32_t ExpectedOrder)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Get_Matrix_GR(ctx, ExpectedOrder);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SymMatrix(int32_t ExpectedOrder)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Get_SymMatrix_GR(ctx, ExpectedOrder);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Vector(int32_t ExpectedSize)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Get_Vector_GR(ctx, ExpectedSize);
            return api_util->get_float64_gr_array<VectorT>();
        }
        void ResetDelimiters()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_ResetDelimiters(ctx);
        }
 
        bool AutoIncrement() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Parser_Get_AutoIncrement(ctx) != 0);
        }
        IParser& AutoIncrement(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_AutoIncrement(ctx, value);
            return *this;
        }
 
        string BeginQuote() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_BeginQuote(ctx);
        }
        IParser& BeginQuote(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_BeginQuote(ctx, value);
            return *this;
        }
        IParser& BeginQuote(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_BeginQuote(ctx, value.c_str());
            return *this;
        }
 
        string CmdString() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_CmdString(ctx);
        }
        IParser& CmdString(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_CmdString(ctx, value);
            return *this;
        }
        IParser& CmdString(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_CmdString(ctx, value.c_str());
            return *this;
        }
 
        double DblValue() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_DblValue(ctx);
        }
 
        string Delimiters() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_Delimiters(ctx);
        }
        IParser& Delimiters(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_Delimiters(ctx, value);
            return *this;
        }
        IParser& Delimiters(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_Delimiters(ctx, value.c_str());
            return *this;
        }
 
        string EndQuote() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_EndQuote(ctx);
        }
        IParser& EndQuote(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_EndQuote(ctx, value);
            return *this;
        }
        IParser& EndQuote(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_EndQuote(ctx, value.c_str());
            return *this;
        }
 
        int32_t IntValue() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_IntValue(ctx);
        }
 
        string NextParam() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_NextParam(ctx);
        }
 
        string StrValue() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_StrValue(ctx);
        }
 
        string WhiteSpace() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parser_Get_WhiteSpace(ctx);
        }
        IParser& WhiteSpace(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_WhiteSpace(ctx, value);
            return *this;
        }
        IParser& WhiteSpace(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parser_Set_WhiteSpace(ctx, value.c_str());
            return *this;
        }
    };
 
    class IReduceCkt: public ContextState
    {
    public:
 
        IReduceCkt(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        double Zmag() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ReduceCkt_Get_Zmag(ctx);
        }
        IReduceCkt& Zmag(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_Zmag(ctx, value);
            return *this;
        }
 
        bool KeepLoad() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_ReduceCkt_Get_KeepLoad(ctx) != 0);
        }
        IReduceCkt& KeepLoad(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_KeepLoad(ctx, value);
            return *this;
        }
 
        string EditString() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ReduceCkt_Get_EditString(ctx);
        }
        IReduceCkt& EditString(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_EditString(ctx, value);
            return *this;
        }
        IReduceCkt& EditString(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_EditString(ctx, value.c_str());
            return *this;
        }
 
        string StartPDElement() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ReduceCkt_Get_StartPDElement(ctx);
        }
        IReduceCkt& StartPDElement(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_StartPDElement(ctx, value);
            return *this;
        }
        IReduceCkt& StartPDElement(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_StartPDElement(ctx, value.c_str());
            return *this;
        }
 
        string EnergyMeter() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ReduceCkt_Get_EnergyMeter(ctx);
        }
        IReduceCkt& EnergyMeter(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_EnergyMeter(ctx, value);
            return *this;
        }
        IReduceCkt& EnergyMeter(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Set_EnergyMeter(ctx, value.c_str());
            return *this;
        }
        void SaveCircuit(const char *CktName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_SaveCircuit(ctx, CktName);
        }
        void SaveCircuit(const string &CktName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_SaveCircuit(ctx, CktName.c_str());
        }
        void DoDefault()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoDefault(ctx);
        }
        void DoShortLines()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoShortLines(ctx);
        }
        void DoDangling()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoDangling(ctx);
        }
        void DoLoopBreak()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoLoopBreak(ctx);
        }
        void DoParallelLines()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoParallelLines(ctx);
        }
        void DoSwitches()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoSwitches(ctx);
        }
        void Do1phLaterals()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_Do1phLaterals(ctx);
        }
        void DoBranchRemove()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ReduceCkt_DoBranchRemove(ctx);
        }
    };
 
    class IYMatrix: public ContextState
    {
    public:
 
        IYMatrix(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        void ZeroInjCurr()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_ZeroInjCurr(ctx);
        }
        void GetSourceInjCurrents()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_GetSourceInjCurrents(ctx);
        }
        void GetPCInjCurr()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_GetPCInjCurr(ctx);
        }
        void BuildYMatrixD(int32_t BuildOps, int32_t AllocateVI)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_BuildYMatrixD(ctx, BuildOps, AllocateVI);
        }
        void AddInAuxCurrents(int32_t SType)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_AddInAuxCurrents(ctx, SType);
        }
 
        bool SystemYChanged() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_YMatrix_Get_SystemYChanged(ctx) != 0);
        }
        IYMatrix& SystemYChanged(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_Set_SystemYChanged(ctx, value);
            return *this;
        }
 
        bool UseAuxCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_YMatrix_Get_UseAuxCurrents(ctx) != 0);
        }
        IYMatrix& UseAuxCurrents(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_Set_UseAuxCurrents(ctx, value);
            return *this;
        }
 
        uint64_t SolverOptions() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_YMatrix_Get_SolverOptions(ctx);
        }
        IYMatrix& SolverOptions(uint64_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_Set_SolverOptions(ctx, value);
            return *this;
        }
        bool CheckConvergence()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_YMatrix_CheckConvergence(ctx) != 0);
        }
        void SetGeneratordQdV()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_SetGeneratordQdV(ctx);
        }
 
        bool LoadsNeedUpdating() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_YMatrix_Get_LoadsNeedUpdating(ctx) != 0);
        }
        IYMatrix& LoadsNeedUpdating(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_Set_LoadsNeedUpdating(ctx, value);
            return *this;
        }
 
        bool SolutionInitialized() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_YMatrix_Get_SolutionInitialized(ctx) != 0);
        }
        IYMatrix& SolutionInitialized(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_Set_SolutionInitialized(ctx, value);
            return *this;
        }
 
        int32_t Iteration() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_YMatrix_Get_Iteration(ctx);
        }
        IYMatrix& Iteration(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_YMatrix_Set_Iteration(ctx, value);
            return *this;
        }
    };
 
    class IMeters: public ContextState
    {
    public:
 
        IMeters(dss::APIUtil *util) :
            ContextState(util)
        {
        }
    
        strings ZonePCE() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Meters_Get_ZonePCE);
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Meters_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_Name(ctx);
        }
 
        IMeters& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_Name(ctx, value);
            return *this;
        }
        IMeters& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_idx(ctx, value);
        }
        void CloseAllDIFiles()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_CloseAllDIFiles(ctx);
        }
        void DoReliabilityCalc(bool AssumeRestoration)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_DoReliabilityCalc(ctx, AssumeRestoration);
        }
        void OpenAllDIFiles()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_OpenAllDIFiles(ctx);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Reset(ctx);
        }
        void ResetAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_ResetAll(ctx);
        }
        void Sample()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Sample(ctx);
        }
        void SampleAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_SampleAll(ctx);
        }
        void Save()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Save(ctx);
        }
        void SaveAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_SaveAll(ctx);
        }
        void SetActiveSection(int32_t SectIdx)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_SetActiveSection(ctx, SectIdx);
        }
 
        strings AllBranchesInZone() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Meters_Get_AllBranchesInZone);
        }
 
        strings AllEndElements() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Meters_Get_AllEndElements);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllocFactors() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Get_AllocFactors_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IMeters& AllocFactors(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_AllocFactors(ctx, &value[0], value.size());
            return *this;
        }
 
        double AvgRepairTime() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_AvgRepairTime(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT CalcCurrent() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Get_CalcCurrent_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IMeters& CalcCurrent(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_CalcCurrent(ctx, &value[0], value.size());
            return *this;
        }
 
        int32_t CountBranches() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_CountBranches(ctx);
        }
 
        int32_t CountEndElements() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_CountEndElements(ctx);
        }
 
        double CustInterrupts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_CustInterrupts(ctx);
        }
 
        bool DIFilesAreOpen() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Meters_Get_DIFilesAreOpen(ctx) != 0);
        }
 
        double FaultRateXRepairHrs() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_FaultRateXRepairHrs(ctx);
        }
 
        string MeteredElement() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_MeteredElement(ctx);
        }
        IMeters& MeteredElement(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_MeteredElement(ctx, value);
            return *this;
        }
        IMeters& MeteredElement(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_MeteredElement(ctx, value.c_str());
            return *this;
        }
 
        int32_t MeteredTerminal() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_MeteredTerminal(ctx);
        }
        IMeters& MeteredTerminal(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_MeteredTerminal(ctx, value);
            return *this;
        }
 
        int32_t NumSectionBranches() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_NumSectionBranches(ctx);
        }
 
        int32_t NumSectionCustomers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_NumSectionCustomers(ctx);
        }
 
        int32_t NumSections() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_NumSections(ctx);
        }
 
        int32_t OCPDeviceType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_OCPDeviceType(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Peakcurrent() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Get_Peakcurrent_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IMeters& Peakcurrent(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_Peakcurrent(ctx, &value[0], value.size());
            return *this;
        }
 
        strings RegisterNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Meters_Get_RegisterNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT RegisterValues() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Get_RegisterValues_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double SAIDI() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SAIDI(ctx);
        }
 
        double SAIFI() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SAIFI(ctx);
        }
 
        double SAIFIKW() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SAIFIKW(ctx);
        }
 
        int32_t SectSeqIdx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SectSeqIdx(ctx);
        }
 
        int32_t SectTotalCust() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SectTotalCust(ctx);
        }
 
        int32_t SeqListSize() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SeqListSize(ctx);
        }
 
        int32_t SequenceIndex() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SequenceIndex(ctx);
        }
        IMeters& SequenceIndex(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Set_SequenceIndex(ctx, value);
            return *this;
        }
 
        double SumBranchFltRates() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_SumBranchFltRates(ctx);
        }
 
        int32_t TotalCustomers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Meters_Get_TotalCustomers(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Totals() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Meters_Get_Totals_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
    };
 
    class IPDElements: public ContextState
    {
    public:
 
        IPDElements(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        double AccumulatedL() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_AccumulatedL(ctx);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_Count(ctx);
        }
 
        double FaultRate() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_FaultRate(ctx);
        }
        IPDElements& FaultRate(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Set_FaultRate(ctx, value);
            return *this;
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_First(ctx);
        }
 
        int32_t FromTerminal() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_FromTerminal(ctx);
        }
 
        bool IsShunt() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_PDElements_Get_IsShunt(ctx) != 0);
        }
 
        double Lambda() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_Lambda(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_Name(ctx);
        }
        IPDElements& Name(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Set_Name(ctx, value);
            return *this;
        }
        IPDElements& Name(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Set_Name(ctx, value.c_str());
            return *this;
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_Next(ctx);
        }
 
        int32_t Numcustomers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_Numcustomers(ctx);
        }
 
        int32_t ParentPDElement() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_ParentPDElement(ctx);
        }
 
        double RepairTime() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_RepairTime(ctx);
        }
        IPDElements& RepairTime(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Set_RepairTime(ctx, value);
            return *this;
        }
 
        int32_t SectionID() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_SectionID(ctx);
        }
 
        double TotalMiles() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_TotalMiles(ctx);
        }
 
        int32_t Totalcustomers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_Totalcustomers(ctx);
        }
 
        double pctPermanent() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PDElements_Get_pctPermanent(ctx);
        }
        IPDElements& pctPermanent(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Set_pctPermanent(ctx, value);
            return *this;
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_PDElements_Get_AllNames);
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllMaxCurrents(bool AllNodes=false)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllMaxCurrents_GR(ctx, AllNodes);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllPctNorm(bool AllNodes=false)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllPctNorm_GR(ctx, AllNodes);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllPctEmerg(bool AllNodes=false)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllPctEmerg_GR(ctx, AllNodes);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllCurrentsMagAng() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllCurrentsMagAng_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllCplxSeqCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllCplxSeqCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllSeqCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllSeqCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllPowers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllPowers_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllSeqPowers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllSeqPowers_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT AllNumPhases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllNumPhases_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT AllNumConductors() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllNumConductors_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT AllNumTerminals() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PDElements_Get_AllNumTerminals_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
    };
 
    class IPVSystems: public ContextState
    {
    public:
 
        IPVSystems(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_PVSystems_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Name(ctx);
        }
 
        IPVSystems& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Name(ctx, value);
            return *this;
        }
        IPVSystems& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_idx(ctx, value);
        }
 
        double Irradiance() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Irradiance(ctx);
        }
        IPVSystems& Irradiance(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Irradiance(ctx, value);
            return *this;
        }
 
        double PF() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_PF(ctx);
        }
        IPVSystems& PF(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_PF(ctx, value);
            return *this;
        }
 
        strings RegisterNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_PVSystems_Get_RegisterNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT RegisterValues() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Get_RegisterValues_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double kVArated() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_kVArated(ctx);
        }
        IPVSystems& kVArated(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_kVArated(ctx, value);
            return *this;
        }
 
        double kW() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_kW(ctx);
        }
 
        double kvar() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_kvar(ctx);
        }
        IPVSystems& kvar(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_kvar(ctx, value);
            return *this;
        }
 
        string daily() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_daily(ctx);
        }
        IPVSystems& daily(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_daily(ctx, value);
            return *this;
        }
        IPVSystems& daily(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_daily(ctx, value.c_str());
            return *this;
        }
 
        string duty() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_duty(ctx);
        }
        IPVSystems& duty(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_duty(ctx, value);
            return *this;
        }
        IPVSystems& duty(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_duty(ctx, value.c_str());
            return *this;
        }
 
        string yearly() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_yearly(ctx);
        }
        IPVSystems& yearly(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_yearly(ctx, value);
            return *this;
        }
        IPVSystems& yearly(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_yearly(ctx, value.c_str());
            return *this;
        }
 
        string Tdaily() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Tdaily(ctx);
        }
        IPVSystems& Tdaily(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Tdaily(ctx, value);
            return *this;
        }
        IPVSystems& Tdaily(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Tdaily(ctx, value.c_str());
            return *this;
        }
 
        string Tduty() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Tduty(ctx);
        }
        IPVSystems& Tduty(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Tduty(ctx, value);
            return *this;
        }
        IPVSystems& Tduty(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Tduty(ctx, value.c_str());
            return *this;
        }
 
        string Tyearly() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Tyearly(ctx);
        }
        IPVSystems& Tyearly(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Tyearly(ctx, value);
            return *this;
        }
        IPVSystems& Tyearly(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Tyearly(ctx, value.c_str());
            return *this;
        }
 
        double IrradianceNow() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_IrradianceNow(ctx);
        }
 
        double Pmpp() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Pmpp(ctx);
        }
        IPVSystems& Pmpp(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_PVSystems_Set_Pmpp(ctx, value);
            return *this;
        }
 
        string Sensor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_PVSystems_Get_Sensor(ctx);
        }
    };
 
    class IParallel: public ContextState
    {
    public:
 
        IParallel(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        void CreateActor()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_CreateActor(ctx);
        }
        void Wait()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Wait(ctx);
        }
 
        int32_t ActiveActor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_ActiveActor(ctx);
        }
        IParallel& ActiveActor(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Set_ActiveActor(ctx, value);
            return *this;
        }
 
        int32_t ActiveParallel() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_ActiveParallel(ctx);
        }
        IParallel& ActiveParallel(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Set_ActiveParallel(ctx, value);
            return *this;
        }
 
        int32_t ActorCPU() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_ActorCPU(ctx);
        }
        IParallel& ActorCPU(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Set_ActorCPU(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT ActorProgress() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Get_ActorProgress_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT ActorStatus() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Get_ActorStatus_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        int32_t ConcatenateReports() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_ConcatenateReports(ctx);
        }
        IParallel& ConcatenateReports(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Parallel_Set_ConcatenateReports(ctx, value);
            return *this;
        }
 
        int32_t NumCPUs() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_NumCPUs(ctx);
        }
 
        int32_t NumCores() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_NumCores(ctx);
        }
 
        int32_t NumOfActors() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Parallel_Get_NumOfActors(ctx);
        }
    };
 
    class IReactors: public ContextState
    {
    public:
 
        IReactors(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Reactors_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Name(ctx);
        }
 
        IReactors& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Name(ctx, value);
            return *this;
        }
        IReactors& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_idx(ctx, value);
        }
 
        int32_t SpecType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_SpecType(ctx);
        }
 
        bool IsDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Reactors_Get_IsDelta(ctx) != 0);
        }
        IReactors& IsDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_IsDelta(ctx, value);
            return *this;
        }
 
        bool Parallel() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Reactors_Get_Parallel(ctx) != 0);
        }
        IReactors& Parallel(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Parallel(ctx, value);
            return *this;
        }
 
        double LmH() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_LmH(ctx);
        }
        IReactors& LmH(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_LmH(ctx, value);
            return *this;
        }
 
        double kV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_kV(ctx);
        }
        IReactors& kV(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_kV(ctx, value);
            return *this;
        }
 
        double kvar() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_kvar(ctx);
        }
        IReactors& kvar(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_kvar(ctx, value);
            return *this;
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Phases(ctx);
        }
        IReactors& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Phases(ctx, value);
            return *this;
        }
 
        string Bus1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Bus1(ctx);
        }
        IReactors& Bus1(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Bus1(ctx, value);
            return *this;
        }
        IReactors& Bus1(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Bus1(ctx, value.c_str());
            return *this;
        }
 
        string Bus2() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Bus2(ctx);
        }
        IReactors& Bus2(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Bus2(ctx, value);
            return *this;
        }
        IReactors& Bus2(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Bus2(ctx, value.c_str());
            return *this;
        }
 
        string LCurve() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_LCurve(ctx);
        }
        IReactors& LCurve(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_LCurve(ctx, value);
            return *this;
        }
        IReactors& LCurve(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_LCurve(ctx, value.c_str());
            return *this;
        }
 
        string RCurve() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_RCurve(ctx);
        }
        IReactors& RCurve(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_RCurve(ctx, value);
            return *this;
        }
        IReactors& RCurve(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_RCurve(ctx, value.c_str());
            return *this;
        }
 
        double R() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_R(ctx);
        }
        IReactors& R(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_R(ctx, value);
            return *this;
        }
 
        double X() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_X(ctx);
        }
        IReactors& X(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_X(ctx, value);
            return *this;
        }
 
        double Rp() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reactors_Get_Rp(ctx);
        }
        IReactors& Rp(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Rp(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Rmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Get_Rmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IReactors& Rmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Rmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Get_Xmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IReactors& Xmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Xmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Z() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Get_Z_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IReactors& Z(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Z(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Z1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Get_Z1_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IReactors& Z1(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Z1(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Z2() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Get_Z2_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IReactors& Z2(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Z2(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Z0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Get_Z0_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IReactors& Z0(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reactors_Set_Z0(ctx, &value[0], value.size());
            return *this;
        }
    };
 
    class IReclosers: public ContextState
    {
    public:
 
        IReclosers(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Reclosers_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_Name(ctx);
        }
 
        IReclosers& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_Name(ctx, value);
            return *this;
        }
        IReclosers& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_idx(ctx, value);
        }
        void Close()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Close(ctx);
        }
        void Open()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Open(ctx);
        }
 
        double GroundInst() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_GroundInst(ctx);
        }
        IReclosers& GroundInst(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_GroundInst(ctx, value);
            return *this;
        }
 
        double GroundTrip() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_GroundTrip(ctx);
        }
        IReclosers& GroundTrip(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_GroundTrip(ctx, value);
            return *this;
        }
 
        string MonitoredObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_MonitoredObj(ctx);
        }
        IReclosers& MonitoredObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_MonitoredObj(ctx, value);
            return *this;
        }
        IReclosers& MonitoredObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_MonitoredObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t MonitoredTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_MonitoredTerm(ctx);
        }
        IReclosers& MonitoredTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_MonitoredTerm(ctx, value);
            return *this;
        }
 
        int32_t NumFast() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_NumFast(ctx);
        }
        IReclosers& NumFast(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_NumFast(ctx, value);
            return *this;
        }
 
        double PhaseInst() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_PhaseInst(ctx);
        }
        IReclosers& PhaseInst(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_PhaseInst(ctx, value);
            return *this;
        }
 
        double PhaseTrip() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_PhaseTrip(ctx);
        }
        IReclosers& PhaseTrip(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_PhaseTrip(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT RecloseIntervals() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Get_RecloseIntervals_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        int32_t Shots() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_Shots(ctx);
        }
        IReclosers& Shots(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_Shots(ctx, value);
            return *this;
        }
 
        string SwitchedObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_SwitchedObj(ctx);
        }
        IReclosers& SwitchedObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_SwitchedObj(ctx, value);
            return *this;
        }
        IReclosers& SwitchedObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_SwitchedObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t SwitchedTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_SwitchedTerm(ctx);
        }
        IReclosers& SwitchedTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_SwitchedTerm(ctx, value);
            return *this;
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Reset(ctx);
        }
 
        int32_t State() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_State(ctx);
        }
        IReclosers& State(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_State(ctx, value);
            return *this;
        }
 
        int32_t NormalState() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Reclosers_Get_NormalState(ctx);
        }
        IReclosers& NormalState(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Reclosers_Set_NormalState(ctx, value);
            return *this;
        }
    };
 
    class IRegControls: public ContextState
    {
    public:
 
        IRegControls(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_RegControls_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_Name(ctx);
        }
 
        IRegControls& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_Name(ctx, value);
            return *this;
        }
        IRegControls& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_idx(ctx, value);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Reset(ctx);
        }
 
        double CTPrimary() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_CTPrimary(ctx);
        }
        IRegControls& CTPrimary(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_CTPrimary(ctx, value);
            return *this;
        }
 
        double Delay() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_Delay(ctx);
        }
        IRegControls& Delay(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_Delay(ctx, value);
            return *this;
        }
 
        double ForwardBand() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ForwardBand(ctx);
        }
        IRegControls& ForwardBand(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ForwardBand(ctx, value);
            return *this;
        }
 
        double ForwardR() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ForwardR(ctx);
        }
        IRegControls& ForwardR(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ForwardR(ctx, value);
            return *this;
        }
 
        double ForwardVreg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ForwardVreg(ctx);
        }
        IRegControls& ForwardVreg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ForwardVreg(ctx, value);
            return *this;
        }
 
        double ForwardX() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ForwardX(ctx);
        }
        IRegControls& ForwardX(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ForwardX(ctx, value);
            return *this;
        }
 
        bool IsInverseTime() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_RegControls_Get_IsInverseTime(ctx) != 0);
        }
        IRegControls& IsInverseTime(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_IsInverseTime(ctx, value);
            return *this;
        }
 
        bool IsReversible() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_RegControls_Get_IsReversible(ctx) != 0);
        }
        IRegControls& IsReversible(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_IsReversible(ctx, value);
            return *this;
        }
 
        int32_t MaxTapChange() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_MaxTapChange(ctx);
        }
        IRegControls& MaxTapChange(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_MaxTapChange(ctx, value);
            return *this;
        }
 
        string MonitoredBus() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_MonitoredBus(ctx);
        }
        IRegControls& MonitoredBus(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_MonitoredBus(ctx, value);
            return *this;
        }
        IRegControls& MonitoredBus(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_MonitoredBus(ctx, value.c_str());
            return *this;
        }
 
        double PTratio() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_PTratio(ctx);
        }
        IRegControls& PTratio(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_PTratio(ctx, value);
            return *this;
        }
 
        double ReverseBand() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ReverseBand(ctx);
        }
        IRegControls& ReverseBand(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ReverseBand(ctx, value);
            return *this;
        }
 
        double ReverseR() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ReverseR(ctx);
        }
        IRegControls& ReverseR(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ReverseR(ctx, value);
            return *this;
        }
 
        double ReverseVreg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ReverseVreg(ctx);
        }
        IRegControls& ReverseVreg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ReverseVreg(ctx, value);
            return *this;
        }
 
        double ReverseX() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_ReverseX(ctx);
        }
        IRegControls& ReverseX(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_ReverseX(ctx, value);
            return *this;
        }
 
        double TapDelay() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_TapDelay(ctx);
        }
        IRegControls& TapDelay(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_TapDelay(ctx, value);
            return *this;
        }
 
        int32_t TapNumber() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_TapNumber(ctx);
        }
        IRegControls& TapNumber(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_TapNumber(ctx, value);
            return *this;
        }
 
        int32_t TapWinding() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_TapWinding(ctx);
        }
        IRegControls& TapWinding(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_TapWinding(ctx, value);
            return *this;
        }
 
        string Transformer() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_Transformer(ctx);
        }
        IRegControls& Transformer(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_Transformer(ctx, value);
            return *this;
        }
        IRegControls& Transformer(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_Transformer(ctx, value.c_str());
            return *this;
        }
 
        double VoltageLimit() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_VoltageLimit(ctx);
        }
        IRegControls& VoltageLimit(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_VoltageLimit(ctx, value);
            return *this;
        }
 
        int32_t Winding() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_RegControls_Get_Winding(ctx);
        }
        IRegControls& Winding(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_RegControls_Set_Winding(ctx, value);
            return *this;
        }
    };
 
    class IRelays: public ContextState
    {
    public:
 
        IRelays(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Relays_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_Name(ctx);
        }
 
        IRelays& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_Name(ctx, value);
            return *this;
        }
        IRelays& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_idx(ctx, value);
        }
 
        string MonitoredObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_MonitoredObj(ctx);
        }
        IRelays& MonitoredObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_MonitoredObj(ctx, value);
            return *this;
        }
        IRelays& MonitoredObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_MonitoredObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t MonitoredTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_MonitoredTerm(ctx);
        }
        IRelays& MonitoredTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_MonitoredTerm(ctx, value);
            return *this;
        }
 
        string SwitchedObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_SwitchedObj(ctx);
        }
        IRelays& SwitchedObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_SwitchedObj(ctx, value);
            return *this;
        }
        IRelays& SwitchedObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_SwitchedObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t SwitchedTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_SwitchedTerm(ctx);
        }
        IRelays& SwitchedTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_SwitchedTerm(ctx, value);
            return *this;
        }
        void Open()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Open(ctx);
        }
        void Close()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Close(ctx);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Reset(ctx);
        }
 
        int32_t State() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_State(ctx);
        }
        IRelays& State(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_State(ctx, value);
            return *this;
        }
 
        int32_t NormalState() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Relays_Get_NormalState(ctx);
        }
        IRelays& NormalState(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Relays_Set_NormalState(ctx, value);
            return *this;
        }
    };
 
    class ISensors: public ContextState
    {
    public:
 
        ISensors(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Sensors_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_Name(ctx);
        }
 
        ISensors& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_Name(ctx, value);
            return *this;
        }
        ISensors& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_idx(ctx, value);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Reset(ctx);
        }
        void ResetAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_ResetAll(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Currents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Get_Currents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ISensors& Currents(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_Currents(ctx, &value[0], value.size());
            return *this;
        }
 
        bool IsDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Sensors_Get_IsDelta(ctx) != 0);
        }
        ISensors& IsDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_IsDelta(ctx, value);
            return *this;
        }
 
        string MeteredElement() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_MeteredElement(ctx);
        }
        ISensors& MeteredElement(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_MeteredElement(ctx, value);
            return *this;
        }
        ISensors& MeteredElement(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_MeteredElement(ctx, value.c_str());
            return *this;
        }
 
        int32_t MeteredTerminal() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_MeteredTerminal(ctx);
        }
        ISensors& MeteredTerminal(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_MeteredTerminal(ctx, value);
            return *this;
        }
 
        double PctError() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_PctError(ctx);
        }
        ISensors& PctError(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_PctError(ctx, value);
            return *this;
        }
 
        bool ReverseDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Sensors_Get_ReverseDelta(ctx) != 0);
        }
        ISensors& ReverseDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_ReverseDelta(ctx, value);
            return *this;
        }
 
        double Weight() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_Weight(ctx);
        }
        ISensors& Weight(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_Weight(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT kVARS() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Get_kVARS_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ISensors& kVARS(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_kVARS(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT kVS() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Get_kVS_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ISensors& kVS(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_kVS(ctx, &value[0], value.size());
            return *this;
        }
 
        double kVbase() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Sensors_Get_kVbase(ctx);
        }
        ISensors& kVbase(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_kVbase(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT kWS() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Get_kWS_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ISensors& kWS(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Set_kWS(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllocationFactor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Sensors_Get_AllocationFactor_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
    };
 
    class ISwtControls: public ContextState
    {
    public:
 
        ISwtControls(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_SwtControls_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_Name(ctx);
        }
 
        ISwtControls& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_Name(ctx, value);
            return *this;
        }
        ISwtControls& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_idx(ctx, value);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Reset(ctx);
        }
 
        int32_t Action() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_Action(ctx);
        }
        ISwtControls& Action(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_Action(ctx, value);
            return *this;
        }
 
        double Delay() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_Delay(ctx);
        }
        ISwtControls& Delay(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_Delay(ctx, value);
            return *this;
        }
 
        bool IsLocked() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_SwtControls_Get_IsLocked(ctx) != 0);
        }
        ISwtControls& IsLocked(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_IsLocked(ctx, value);
            return *this;
        }
 
        int32_t NormalState() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_NormalState(ctx);
        }
        ISwtControls& NormalState(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_NormalState(ctx, value);
            return *this;
        }
 
        int32_t State() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_State(ctx);
        }
        ISwtControls& State(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_State(ctx, value);
            return *this;
        }
 
        string SwitchedObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_SwitchedObj(ctx);
        }
        ISwtControls& SwitchedObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_SwitchedObj(ctx, value);
            return *this;
        }
        ISwtControls& SwitchedObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_SwitchedObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t SwitchedTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_SwtControls_Get_SwitchedTerm(ctx);
        }
        ISwtControls& SwitchedTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_SwtControls_Set_SwitchedTerm(ctx, value);
            return *this;
        }
    };
 
    class ITSData: public ContextState
    {
    public:
 
        ITSData(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_TSData_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Name(ctx);
        }
 
        ITSData& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_Name(ctx, value);
            return *this;
        }
        ITSData& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_idx(ctx, value);
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_EmergAmps(ctx);
        }
        ITSData& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        double NormAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_NormAmps(ctx);
        }
        ITSData& NormAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_NormAmps(ctx, value);
            return *this;
        }
 
        double Rdc() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Rdc(ctx);
        }
        ITSData& Rdc(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_Rdc(ctx, value);
            return *this;
        }
 
        double Rac() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Rac(ctx);
        }
        ITSData& Rac(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_Rac(ctx, value);
            return *this;
        }
 
        double GMRac() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_GMRac(ctx);
        }
        ITSData& GMRac(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_GMRac(ctx, value);
            return *this;
        }
 
        int32_t GMRUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_GMRUnits(ctx);
        }
        ITSData& GMRUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_GMRUnits(ctx, value);
            return *this;
        }
 
        double Radius() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Radius(ctx);
        }
        ITSData& Radius(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_Radius(ctx, value);
            return *this;
        }
 
        int32_t RadiusUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_RadiusUnits(ctx);
        }
        ITSData& RadiusUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_RadiusUnits(ctx, value);
            return *this;
        }
 
        int32_t ResistanceUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_ResistanceUnits(ctx);
        }
        ITSData& ResistanceUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_ResistanceUnits(ctx, value);
            return *this;
        }
 
        double Diameter() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_Diameter(ctx);
        }
        ITSData& Diameter(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_Diameter(ctx, value);
            return *this;
        }
 
        double EpsR() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_EpsR(ctx);
        }
        ITSData& EpsR(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_EpsR(ctx, value);
            return *this;
        }
 
        double InsLayer() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_InsLayer(ctx);
        }
        ITSData& InsLayer(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_InsLayer(ctx, value);
            return *this;
        }
 
        double DiaIns() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_DiaIns(ctx);
        }
        ITSData& DiaIns(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_DiaIns(ctx, value);
            return *this;
        }
 
        double DiaCable() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_DiaCable(ctx);
        }
        ITSData& DiaCable(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_DiaCable(ctx, value);
            return *this;
        }
 
        double DiaShield() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_DiaShield(ctx);
        }
        ITSData& DiaShield(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_DiaShield(ctx, value);
            return *this;
        }
 
        double TapeLayer() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_TapeLayer(ctx);
        }
        ITSData& TapeLayer(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_TapeLayer(ctx, value);
            return *this;
        }
 
        double TapeLap() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_TSData_Get_TapeLap(ctx);
        }
        ITSData& TapeLap(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_TSData_Set_TapeLap(ctx, value);
            return *this;
        }
    };
 
    class IText: public ContextState
    {
    public:
 
        IText(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        void Commands(const string &value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Text_CommandBlock(ctx, value.c_str());
        }
 
        void Commands(const strings &value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            api_util->set_string_array(ctx_Text_CommandArray, value);
        }
 
        string Command() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Text_Get_Command(ctx);
        }
        IText& Command(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Text_Set_Command(ctx, value);
            return *this;
        }
        IText& Command(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Text_Set_Command(ctx, value.c_str());
            return *this;
        }
 
        string Result() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Text_Get_Result(ctx);
        }
    };
 
    class ITopology: public ContextState
    {
    public:
 
        ITopology(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        int32_t ActiveBranch() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_ActiveBranch(ctx);
        }
 
        int32_t ActiveLevel() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_ActiveLevel(ctx);
        }
 
        strings AllIsolatedBranches() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Topology_Get_AllIsolatedBranches);
        }
 
        strings AllIsolatedLoads() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Topology_Get_AllIsolatedLoads);
        }
 
        strings AllLoopedPairs() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Topology_Get_AllLoopedPairs);
        }
 
        int32_t BackwardBranch() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_BackwardBranch(ctx);
        }
 
        string BranchName() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_BranchName(ctx);
        }
        ITopology& BranchName(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Topology_Set_BranchName(ctx, value);
            return *this;
        }
        ITopology& BranchName(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Topology_Set_BranchName(ctx, value.c_str());
            return *this;
        }
 
        string BusName() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_BusName(ctx);
        }
        ITopology& BusName(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Topology_Set_BusName(ctx, value);
            return *this;
        }
        ITopology& BusName(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Topology_Set_BusName(ctx, value.c_str());
            return *this;
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_First(ctx);
        }
 
        int32_t FirstLoad() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_FirstLoad(ctx);
        }
 
        int32_t ForwardBranch() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_ForwardBranch(ctx);
        }
 
        int32_t LoopedBranch() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_LoopedBranch(ctx);
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_Next(ctx);
        }
 
        int32_t NextLoad() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_NextLoad(ctx);
        }
 
        int32_t NumIsolatedBranches() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_NumIsolatedBranches(ctx);
        }
 
        int32_t NumIsolatedLoads() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_NumIsolatedLoads(ctx);
        }
 
        int32_t NumLoops() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_NumLoops(ctx);
        }
 
        int32_t ParallelBranch() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Topology_Get_ParallelBranch(ctx);
        }
    };
 
    class ITransformers: public ContextState
    {
    public:
 
        ITransformers(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Transformers_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Name(ctx);
        }
 
        ITransformers& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Name(ctx, value);
            return *this;
        }
        ITransformers& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_idx(ctx, value);
        }
 
        bool IsDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Transformers_Get_IsDelta(ctx) != 0);
        }
        ITransformers& IsDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_IsDelta(ctx, value);
            return *this;
        }
 
        double MaxTap() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_MaxTap(ctx);
        }
        ITransformers& MaxTap(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_MaxTap(ctx, value);
            return *this;
        }
 
        double MinTap() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_MinTap(ctx);
        }
        ITransformers& MinTap(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_MinTap(ctx, value);
            return *this;
        }
 
        int32_t NumTaps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_NumTaps(ctx);
        }
        ITransformers& NumTaps(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_NumTaps(ctx, value);
            return *this;
        }
 
        int32_t NumWindings() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_NumWindings(ctx);
        }
        ITransformers& NumWindings(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_NumWindings(ctx, value);
            return *this;
        }
 
        double R() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_R(ctx);
        }
        ITransformers& R(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_R(ctx, value);
            return *this;
        }
 
        double Rneut() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Rneut(ctx);
        }
        ITransformers& Rneut(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Rneut(ctx, value);
            return *this;
        }
 
        double Tap() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Tap(ctx);
        }
        ITransformers& Tap(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Tap(ctx, value);
            return *this;
        }
 
        int32_t Wdg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Wdg(ctx);
        }
        ITransformers& Wdg(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Wdg(ctx, value);
            return *this;
        }
 
        string XfmrCode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_XfmrCode(ctx);
        }
        ITransformers& XfmrCode(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_XfmrCode(ctx, value);
            return *this;
        }
        ITransformers& XfmrCode(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_XfmrCode(ctx, value.c_str());
            return *this;
        }
 
        double Xhl() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Xhl(ctx);
        }
        ITransformers& Xhl(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Xhl(ctx, value);
            return *this;
        }
 
        double Xht() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Xht(ctx);
        }
        ITransformers& Xht(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Xht(ctx, value);
            return *this;
        }
 
        double Xlt() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Xlt(ctx);
        }
        ITransformers& Xlt(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Xlt(ctx, value);
            return *this;
        }
 
        double Xneut() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_Xneut(ctx);
        }
        ITransformers& Xneut(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_Xneut(ctx, value);
            return *this;
        }
 
        double kV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_kV(ctx);
        }
        ITransformers& kV(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_kV(ctx, value);
            return *this;
        }
 
        double kVA() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_kVA(ctx);
        }
        ITransformers& kVA(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_kVA(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT WdgVoltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Get_WdgVoltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT WdgCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Get_WdgCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        string strWdgCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_strWdgCurrents(ctx);
        }
 
        int32_t CoreType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_CoreType(ctx);
        }
        ITransformers& CoreType(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_CoreType(ctx, value);
            return *this;
        }
 
        double RdcOhms() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Transformers_Get_RdcOhms(ctx);
        }
        ITransformers& RdcOhms(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Set_RdcOhms(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT LossesByType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Get_LossesByType_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllLossesByType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Transformers_Get_AllLossesByType_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
    };
 
    class IVsources: public ContextState
    {
    public:
 
        IVsources(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Vsources_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_Name(ctx);
        }
 
        IVsources& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_Name(ctx, value);
            return *this;
        }
        IVsources& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_idx(ctx, value);
        }
 
        double AngleDeg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_AngleDeg(ctx);
        }
        IVsources& AngleDeg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_AngleDeg(ctx, value);
            return *this;
        }
 
        double BasekV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_BasekV(ctx);
        }
        IVsources& BasekV(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_BasekV(ctx, value);
            return *this;
        }
 
        double Frequency() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_Frequency(ctx);
        }
        IVsources& Frequency(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_Frequency(ctx, value);
            return *this;
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_Phases(ctx);
        }
        IVsources& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_Phases(ctx, value);
            return *this;
        }
 
        double pu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Vsources_Get_pu(ctx);
        }
        IVsources& pu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Vsources_Set_pu(ctx, value);
            return *this;
        }
    };
 
    class IWireData: public ContextState
    {
    public:
 
        IWireData(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_WireData_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Name(ctx);
        }
 
        IWireData& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_Name(ctx, value);
            return *this;
        }
        IWireData& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_idx(ctx, value);
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_EmergAmps(ctx);
        }
        IWireData& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        double NormAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_NormAmps(ctx);
        }
        IWireData& NormAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_NormAmps(ctx, value);
            return *this;
        }
 
        double Rdc() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Rdc(ctx);
        }
        IWireData& Rdc(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_Rdc(ctx, value);
            return *this;
        }
 
        double Rac() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Rac(ctx);
        }
        IWireData& Rac(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_Rac(ctx, value);
            return *this;
        }
 
        double GMRac() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_GMRac(ctx);
        }
        IWireData& GMRac(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_GMRac(ctx, value);
            return *this;
        }
 
        int32_t GMRUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_GMRUnits(ctx);
        }
        IWireData& GMRUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_GMRUnits(ctx, value);
            return *this;
        }
 
        double Radius() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Radius(ctx);
        }
        IWireData& Radius(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_Radius(ctx, value);
            return *this;
        }
 
        int32_t RadiusUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_RadiusUnits(ctx);
        }
        IWireData& RadiusUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_RadiusUnits(ctx, value);
            return *this;
        }
 
        int32_t ResistanceUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_ResistanceUnits(ctx);
        }
        IWireData& ResistanceUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_ResistanceUnits(ctx, value);
            return *this;
        }
 
        double Diameter() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_Diameter(ctx);
        }
        IWireData& Diameter(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_Diameter(ctx, value);
            return *this;
        }
 
        double CapRadius() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_WireData_Get_CapRadius(ctx);
        }
        IWireData& CapRadius(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_WireData_Set_CapRadius(ctx, value);
            return *this;
        }
    };
 
    class IXYCurves: public ContextState
    {
    public:
 
        IXYCurves(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_XYCurves_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Name(ctx);
        }
 
        IXYCurves& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Name(ctx, value);
            return *this;
        }
        IXYCurves& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_idx(ctx, value);
        }
 
        int32_t Npts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Npts(ctx);
        }
        IXYCurves& Npts(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Npts(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xarray() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Get_Xarray_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IXYCurves& Xarray(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Xarray(ctx, &value[0], value.size());
            return *this;
        }
 
        double Xscale() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Xscale(ctx);
        }
        IXYCurves& Xscale(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Xscale(ctx, value);
            return *this;
        }
 
        double Xshift() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Xshift(ctx);
        }
        IXYCurves& Xshift(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Xshift(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Yarray() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Get_Yarray_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        IXYCurves& Yarray(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Yarray(ctx, &value[0], value.size());
            return *this;
        }
 
        double Yscale() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Yscale(ctx);
        }
        IXYCurves& Yscale(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Yscale(ctx, value);
            return *this;
        }
 
        double Yshift() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_Yshift(ctx);
        }
        IXYCurves& Yshift(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_Yshift(ctx, value);
            return *this;
        }
 
        double x() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_x(ctx);
        }
        IXYCurves& x(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_x(ctx, value);
            return *this;
        }
 
        double y() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_XYCurves_Get_y(ctx);
        }
        IXYCurves& y(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_XYCurves_Set_y(ctx, value);
            return *this;
        }
    };
 
    class IZIP: public ContextState
    {
    public:
 
        IZIP(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings List(const char *regexp="")
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_ZIP_List, regexp);
        }
        strings List(const string& regexp)
        {
            return List(regexp.c_str());
        }
        void Open(const char *FileName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Open(ctx, FileName);
        }
        void Open(const string &FileName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Open(ctx, FileName.c_str());
        }
        void Close()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Close(ctx);
        }
        void Redirect(const char *FileInZip)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Redirect(ctx, FileInZip);
        }
        void Redirect(const string &FileInZip)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Redirect(ctx, FileInZip.c_str());
        }
        template <typename VectorT=Eigen::Matrix<int8_t, Eigen::Dynamic, 1>>
        VectorT Extract(const char *FileName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Extract_GR(ctx, FileName);
            return api_util->get_int8_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<int8_t, Eigen::Dynamic, 1>>
        VectorT Extract(const string &FileName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ZIP_Extract_GR(ctx, FileName.c_str());
            return api_util->get_int8_gr_array<VectorT>();
        }
        bool Contains(const char *Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_ZIP_Contains(ctx, Name) != 0);
        }
        bool Contains(const string &Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_ZIP_Contains(ctx, Name.c_str()) != 0);
        }
    };
 
    class IActiveClass: public ContextState
    {
    public:
 
        IActiveClass(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        string ActiveClassName() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_ActiveClassName(ctx);
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_ActiveClass_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_Name(ctx);
        }
        IActiveClass& Name(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ActiveClass_Set_Name(ctx, value);
            return *this;
        }
        IActiveClass& Name(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_ActiveClass_Set_Name(ctx, value.c_str());
            return *this;
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_Next(ctx);
        }
 
        int32_t NumElements() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_NumElements(ctx);
        }
 
        string ActiveClassParent() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_Get_ActiveClassParent(ctx);
        }
        string ToJSON(int32_t options=0)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_ActiveClass_ToJSON(ctx, options);
        }
    };
 
    class IBus: public ContextState
    {
    public:
 
        IBus(dss::APIUtil *util) :
            ContextState(util)
        {
        }
    
        IBus& operator[](int32_t key) // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_SetActiveBusi(ctx, key);
            return *this;
        }
 
        IBus& operator[](const char *key) // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_SetActiveBus(ctx, key);
            return *this;
        }
        IBus& operator[](const string &key) // getter
        {
            return (*this)[key.c_str()];
        }
 
        strings AllPCEatBus() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Bus_Get_AllPCEatBus);
        }
 
        strings AllPDEatBus() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Bus_Get_AllPDEatBus);
        }
        int32_t GetUniqueNodeNumber(int32_t StartNumber)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_GetUniqueNodeNumber(ctx, StartNumber);
        }
        bool ZscRefresh()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Bus_ZscRefresh(ctx) != 0);
        }
 
        bool Coorddefined() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Bus_Get_Coorddefined(ctx) != 0);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT CplxSeqVoltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_CplxSeqVoltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double Cust_Duration() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_Cust_Duration(ctx);
        }
 
        double Cust_Interrupts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_Cust_Interrupts(ctx);
        }
 
        double Distance() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_Distance(ctx);
        }
 
        double Int_Duration() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_Int_Duration(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Isc() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_Isc_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double Lambda() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_Lambda(ctx);
        }
 
        int32_t N_Customers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_N_Customers(ctx);
        }
 
        double N_interrupts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_N_interrupts(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_Name(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT Nodes() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_Nodes_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        int32_t NumNodes() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_NumNodes(ctx);
        }
 
        int32_t SectionID() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_SectionID(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SeqVoltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_SeqVoltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double TotalMiles() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_TotalMiles(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT VLL() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_VLL_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT VMagAngle() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_VMagAngle_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Voc() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_Voc_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Voltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_Voltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT YscMatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_YscMatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Zsc0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_Zsc0_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Zsc1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_Zsc1_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT ZscMatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_ZscMatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double kVBase() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_kVBase(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT puVLL() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_puVLL_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT puVmagAngle() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_puVmagAngle_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT puVoltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_puVoltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT ZSC012Matrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Get_ZSC012Matrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        double x() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_x(ctx);
        }
        IBus& x(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Set_x(ctx, value);
            return *this;
        }
 
        double y() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Bus_Get_y(ctx);
        }
        IBus& y(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Bus_Set_y(ctx, value);
            return *this;
        }
 
        strings LoadList() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Bus_Get_LoadList);
        }
 
        strings LineList() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Bus_Get_LineList);
        }
 
    };
 
    class ICNData: public ContextState
    {
    public:
 
        ICNData(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_CNData_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Name(ctx);
        }
 
        ICNData& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_Name(ctx, value);
            return *this;
        }
        ICNData& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_idx(ctx, value);
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_EmergAmps(ctx);
        }
        ICNData& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        double NormAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_NormAmps(ctx);
        }
        ICNData& NormAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_NormAmps(ctx, value);
            return *this;
        }
 
        double Rdc() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Rdc(ctx);
        }
        ICNData& Rdc(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_Rdc(ctx, value);
            return *this;
        }
 
        double Rac() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Rac(ctx);
        }
        ICNData& Rac(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_Rac(ctx, value);
            return *this;
        }
 
        double GMRac() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_GMRac(ctx);
        }
        ICNData& GMRac(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_GMRac(ctx, value);
            return *this;
        }
 
        int32_t GMRUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_GMRUnits(ctx);
        }
        ICNData& GMRUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_GMRUnits(ctx, value);
            return *this;
        }
 
        double Radius() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Radius(ctx);
        }
        ICNData& Radius(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_Radius(ctx, value);
            return *this;
        }
 
        int32_t RadiusUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_RadiusUnits(ctx);
        }
        ICNData& RadiusUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_RadiusUnits(ctx, value);
            return *this;
        }
 
        int32_t ResistanceUnits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_ResistanceUnits(ctx);
        }
        ICNData& ResistanceUnits(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_ResistanceUnits(ctx, value);
            return *this;
        }
 
        double Diameter() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_Diameter(ctx);
        }
        ICNData& Diameter(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_Diameter(ctx, value);
            return *this;
        }
 
        double EpsR() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_EpsR(ctx);
        }
        ICNData& EpsR(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_EpsR(ctx, value);
            return *this;
        }
 
        double InsLayer() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_InsLayer(ctx);
        }
        ICNData& InsLayer(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_InsLayer(ctx, value);
            return *this;
        }
 
        double DiaIns() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_DiaIns(ctx);
        }
        ICNData& DiaIns(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_DiaIns(ctx, value);
            return *this;
        }
 
        double DiaCable() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_DiaCable(ctx);
        }
        ICNData& DiaCable(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_DiaCable(ctx, value);
            return *this;
        }
 
        int32_t k() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_k(ctx);
        }
        ICNData& k(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_k(ctx, value);
            return *this;
        }
 
        double DiaStrand() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_DiaStrand(ctx);
        }
        ICNData& DiaStrand(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_DiaStrand(ctx, value);
            return *this;
        }
 
        double GmrStrand() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_GmrStrand(ctx);
        }
        ICNData& GmrStrand(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_GmrStrand(ctx, value);
            return *this;
        }
 
        double RStrand() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CNData_Get_RStrand(ctx);
        }
        ICNData& RStrand(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CNData_Set_RStrand(ctx, value);
            return *this;
        }
    };
 
    class ICapControls: public ContextState
    {
    public:
 
        ICapControls(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_CapControls_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Name(ctx);
        }
 
        ICapControls& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Name(ctx, value);
            return *this;
        }
        ICapControls& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_idx(ctx, value);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Reset(ctx);
        }
 
        double CTratio() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_CTratio(ctx);
        }
        ICapControls& CTratio(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_CTratio(ctx, value);
            return *this;
        }
 
        string Capacitor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Capacitor(ctx);
        }
        ICapControls& Capacitor(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Capacitor(ctx, value);
            return *this;
        }
        ICapControls& Capacitor(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Capacitor(ctx, value.c_str());
            return *this;
        }
 
        double DeadTime() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_DeadTime(ctx);
        }
        ICapControls& DeadTime(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_DeadTime(ctx, value);
            return *this;
        }
 
        double Delay() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Delay(ctx);
        }
        ICapControls& Delay(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Delay(ctx, value);
            return *this;
        }
 
        double DelayOff() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_DelayOff(ctx);
        }
        ICapControls& DelayOff(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_DelayOff(ctx, value);
            return *this;
        }
 
        int32_t Mode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Mode(ctx);
        }
        ICapControls& Mode(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Mode(ctx, value);
            return *this;
        }
 
        string MonitoredObj() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_MonitoredObj(ctx);
        }
        ICapControls& MonitoredObj(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_MonitoredObj(ctx, value);
            return *this;
        }
        ICapControls& MonitoredObj(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_MonitoredObj(ctx, value.c_str());
            return *this;
        }
 
        int32_t MonitoredTerm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_MonitoredTerm(ctx);
        }
        ICapControls& MonitoredTerm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_MonitoredTerm(ctx, value);
            return *this;
        }
 
        double OFFSetting() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_OFFSetting(ctx);
        }
        ICapControls& OFFSetting(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_OFFSetting(ctx, value);
            return *this;
        }
 
        double ONSetting() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_ONSetting(ctx);
        }
        ICapControls& ONSetting(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_ONSetting(ctx, value);
            return *this;
        }
 
        double PTratio() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_PTratio(ctx);
        }
        ICapControls& PTratio(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_PTratio(ctx, value);
            return *this;
        }
 
        bool UseVoltOverride() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CapControls_Get_UseVoltOverride(ctx) != 0);
        }
        ICapControls& UseVoltOverride(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_UseVoltOverride(ctx, value);
            return *this;
        }
 
        double Vmax() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Vmax(ctx);
        }
        ICapControls& Vmax(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Vmax(ctx, value);
            return *this;
        }
 
        double Vmin() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CapControls_Get_Vmin(ctx);
        }
        ICapControls& Vmin(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CapControls_Set_Vmin(ctx, value);
            return *this;
        }
    };
 
    class ICapacitors: public ContextState
    {
    public:
 
        ICapacitors(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Capacitors_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_Name(ctx);
        }
 
        ICapacitors& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_Name(ctx, value);
            return *this;
        }
        ICapacitors& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_idx(ctx, value);
        }
        bool AddStep()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Capacitors_AddStep(ctx) != 0);
        }
        void Close()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Close(ctx);
        }
        void Open()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Open(ctx);
        }
        bool SubtractStep()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Capacitors_SubtractStep(ctx) != 0);
        }
 
        int32_t AvailableSteps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_AvailableSteps(ctx);
        }
 
        bool IsDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Capacitors_Get_IsDelta(ctx) != 0);
        }
        ICapacitors& IsDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_IsDelta(ctx, value);
            return *this;
        }
 
        int32_t NumSteps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_NumSteps(ctx);
        }
        ICapacitors& NumSteps(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_NumSteps(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT States() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Get_States_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        ICapacitors& States(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_States(ctx, &value[0], value.size());
            return *this;
        }
 
        double kV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_kV(ctx);
        }
        ICapacitors& kV(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_kV(ctx, value);
            return *this;
        }
 
        double kvar() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Capacitors_Get_kvar(ctx);
        }
        ICapacitors& kvar(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Capacitors_Set_kvar(ctx, value);
            return *this;
        }
    };
 
    class ICtrlQueue: public ContextState
    {
    public:
 
        ICtrlQueue(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        void ClearActions()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CtrlQueue_ClearActions(ctx);
        }
        void ClearQueue()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CtrlQueue_ClearQueue(ctx);
        }
        void Delete(int32_t ActionHandle)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CtrlQueue_Delete(ctx, ActionHandle);
        }
        void DoAllQueue()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CtrlQueue_DoAllQueue(ctx);
        }
        void Show()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CtrlQueue_Show(ctx);
        }
 
        int32_t ActionCode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CtrlQueue_Get_ActionCode(ctx);
        }
 
        int32_t DeviceHandle() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CtrlQueue_Get_DeviceHandle(ctx);
        }
 
        int32_t NumActions() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CtrlQueue_Get_NumActions(ctx);
        }
        int32_t Push(int32_t Hour, double Seconds, int32_t ActionCode, int32_t DeviceHandle)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CtrlQueue_Push(ctx, Hour, Seconds, ActionCode, DeviceHandle);
        }
 
        int32_t PopAction() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CtrlQueue_Get_PopAction(ctx);
        }
 
        strings Queue() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_CtrlQueue_Get_Queue);
        }
 
        int32_t QueueSize() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CtrlQueue_Get_QueueSize(ctx);
        }
 
        ICtrlQueue& Action(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CtrlQueue_Set_Action(ctx, value);
            return *this;
        }
    };
 
    class IDSSElement: public ContextState
    {
    public:
        IDSSProperty Properties;
 
        IDSSElement(dss::APIUtil *util) :
            ContextState(util),
            Properties(util)
        {
        }
 
        strings AllPropertyNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_DSSElement_Get_AllPropertyNames);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSSElement_Get_Name(ctx);
        }
 
        int32_t NumProperties() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSSElement_Get_NumProperties(ctx);
        }
        string ToJSON(int32_t options=0)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSSElement_ToJSON(ctx, options);
        }
    };
 
    class ILineGeometries: public ContextState
    {
    public:
 
        ILineGeometries(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_LineGeometries_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_Name(ctx);
        }
 
        ILineGeometries& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Name(ctx, value);
            return *this;
        }
        ILineGeometries& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_idx(ctx, value);
        }
 
        strings Conductors() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_LineGeometries_Get_Conductors);
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_EmergAmps(ctx);
        }
        ILineGeometries& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        double NormAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_NormAmps(ctx);
        }
        ILineGeometries& NormAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_NormAmps(ctx, value);
            return *this;
        }
 
        double RhoEarth() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_RhoEarth(ctx);
        }
        ILineGeometries& RhoEarth(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_RhoEarth(ctx, value);
            return *this;
        }
 
        bool Reduce() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_LineGeometries_Get_Reduce(ctx) != 0);
        }
        ILineGeometries& Reduce(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Reduce(ctx, value);
            return *this;
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_Phases(ctx);
        }
        ILineGeometries& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Phases(ctx, value);
            return *this;
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Rmatrix(double Frequency, double Length, int32_t Units)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Rmatrix_GR(ctx, Frequency, Length, Units);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xmatrix(double Frequency, double Length, int32_t Units)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Xmatrix_GR(ctx, Frequency, Length, Units);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Zmatrix(double Frequency, double Length, int32_t Units)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Zmatrix_GR(ctx, Frequency, Length, Units);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Cmatrix(double Frequency, double Length, int32_t Units)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Cmatrix_GR(ctx, Frequency, Length, Units);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT Units() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Units_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        ILineGeometries& Units(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Units(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xcoords() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Xcoords_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineGeometries& Xcoords(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Xcoords(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Ycoords() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Get_Ycoords_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILineGeometries& Ycoords(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Ycoords(ctx, &value[0], value.size());
            return *this;
        }
 
        int32_t Nconds() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_LineGeometries_Get_Nconds(ctx);
        }
        ILineGeometries& Nconds(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_LineGeometries_Set_Nconds(ctx, value);
            return *this;
        }
    };
 
    class ILines: public ContextState
    {
    public:
 
        ILines(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Lines_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Name(ctx);
        }
 
        ILines& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Name(ctx, value);
            return *this;
        }
        ILines& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_idx(ctx, value);
        }
        int32_t New(const char *Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_New(ctx, Name);
        }
        int32_t New(const string &Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_New(ctx, Name.c_str());
        }
 
        string Bus1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Bus1(ctx);
        }
        ILines& Bus1(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Bus1(ctx, value);
            return *this;
        }
        ILines& Bus1(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Bus1(ctx, value.c_str());
            return *this;
        }
 
        string Bus2() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Bus2(ctx);
        }
        ILines& Bus2(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Bus2(ctx, value);
            return *this;
        }
        ILines& Bus2(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Bus2(ctx, value.c_str());
            return *this;
        }
 
        double C0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_C0(ctx);
        }
        ILines& C0(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_C0(ctx, value);
            return *this;
        }
 
        double C1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_C1(ctx);
        }
        ILines& C1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_C1(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Cmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Get_Cmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILines& Cmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Cmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_EmergAmps(ctx);
        }
        ILines& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        string Geometry() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Geometry(ctx);
        }
        ILines& Geometry(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Geometry(ctx, value);
            return *this;
        }
        ILines& Geometry(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Geometry(ctx, value.c_str());
            return *this;
        }
 
        double Length() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Length(ctx);
        }
        ILines& Length(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Length(ctx, value);
            return *this;
        }
 
        string LineCode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_LineCode(ctx);
        }
        ILines& LineCode(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_LineCode(ctx, value);
            return *this;
        }
        ILines& LineCode(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_LineCode(ctx, value.c_str());
            return *this;
        }
 
        double NormAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_NormAmps(ctx);
        }
        ILines& NormAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_NormAmps(ctx, value);
            return *this;
        }
 
        int32_t NumCust() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_NumCust(ctx);
        }
 
        int32_t Parent() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Parent(ctx);
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Phases(ctx);
        }
        ILines& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Phases(ctx, value);
            return *this;
        }
 
        double R0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_R0(ctx);
        }
        ILines& R0(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_R0(ctx, value);
            return *this;
        }
 
        double R1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_R1(ctx);
        }
        ILines& R1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_R1(ctx, value);
            return *this;
        }
 
        double Rg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Rg(ctx);
        }
        ILines& Rg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Rg(ctx, value);
            return *this;
        }
 
        double Rho() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Rho(ctx);
        }
        ILines& Rho(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Rho(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Rmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Get_Rmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILines& Rmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Rmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        string Spacing() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Spacing(ctx);
        }
        ILines& Spacing(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Spacing(ctx, value);
            return *this;
        }
        ILines& Spacing(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Spacing(ctx, value.c_str());
            return *this;
        }
 
        int32_t TotalCust() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_TotalCust(ctx);
        }
 
        int32_t Units() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Units(ctx);
        }
        ILines& Units(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Units(ctx, value);
            return *this;
        }
 
        double X0() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_X0(ctx);
        }
        ILines& X0(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_X0(ctx, value);
            return *this;
        }
 
        double X1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_X1(ctx);
        }
        ILines& X1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_X1(ctx, value);
            return *this;
        }
 
        double Xg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_Xg(ctx);
        }
        ILines& Xg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Xg(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Xmatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Get_Xmatrix_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILines& Xmatrix(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Xmatrix(ctx, &value[0], value.size());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Yprim() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Get_Yprim_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILines& Yprim(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_Yprim(ctx, &value[0], value.size());
            return *this;
        }
 
        double SeasonRating() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Lines_Get_SeasonRating(ctx);
        }
 
        bool IsSwitch() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Lines_Get_IsSwitch(ctx) != 0);
        }
        ILines& IsSwitch(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Lines_Set_IsSwitch(ctx, value);
            return *this;
        }
    };
 
    class ILoads: public ContextState
    {
    public:
 
        ILoads(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Loads_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Name(ctx);
        }
 
        ILoads& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Name(ctx, value);
            return *this;
        }
        ILoads& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_idx(ctx, value);
        }
 
        double AllocationFactor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_AllocationFactor(ctx);
        }
        ILoads& AllocationFactor(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_AllocationFactor(ctx, value);
            return *this;
        }
 
        string CVRcurve() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_CVRcurve(ctx);
        }
        ILoads& CVRcurve(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_CVRcurve(ctx, value);
            return *this;
        }
        ILoads& CVRcurve(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_CVRcurve(ctx, value.c_str());
            return *this;
        }
 
        double CVRvars() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_CVRvars(ctx);
        }
        ILoads& CVRvars(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_CVRvars(ctx, value);
            return *this;
        }
 
        double CVRwatts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_CVRwatts(ctx);
        }
        ILoads& CVRwatts(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_CVRwatts(ctx, value);
            return *this;
        }
 
        double Cfactor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Cfactor(ctx);
        }
        ILoads& Cfactor(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Cfactor(ctx, value);
            return *this;
        }
 
        int32_t Class() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Class_(ctx);
        }
        ILoads& Class(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Class_(ctx, value);
            return *this;
        }
 
        string Growth() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Growth(ctx);
        }
        ILoads& Growth(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Growth(ctx, value);
            return *this;
        }
        ILoads& Growth(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Growth(ctx, value.c_str());
            return *this;
        }
 
        bool IsDelta() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Loads_Get_IsDelta(ctx) != 0);
        }
        ILoads& IsDelta(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_IsDelta(ctx, value);
            return *this;
        }
 
        int32_t Model() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Model(ctx);
        }
        ILoads& Model(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Model(ctx, value);
            return *this;
        }
 
        int32_t NumCust() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_NumCust(ctx);
        }
        ILoads& NumCust(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_NumCust(ctx, value);
            return *this;
        }
 
        double PF() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_PF(ctx);
        }
        ILoads& PF(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_PF(ctx, value);
            return *this;
        }
 
        double PctMean() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_PctMean(ctx);
        }
        ILoads& PctMean(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_PctMean(ctx, value);
            return *this;
        }
 
        double PctStdDev() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_PctStdDev(ctx);
        }
        ILoads& PctStdDev(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_PctStdDev(ctx, value);
            return *this;
        }
 
        double RelWeight() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_RelWeight(ctx);
        }
        ILoads& RelWeight(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_RelWeight(ctx, value);
            return *this;
        }
 
        double Rneut() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Rneut(ctx);
        }
        ILoads& Rneut(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Rneut(ctx, value);
            return *this;
        }
 
        string Spectrum() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Spectrum(ctx);
        }
        ILoads& Spectrum(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Spectrum(ctx, value);
            return *this;
        }
        ILoads& Spectrum(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Spectrum(ctx, value.c_str());
            return *this;
        }
 
        int32_t Status() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Status(ctx);
        }
        ILoads& Status(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Status(ctx, value);
            return *this;
        }
 
        double Vmaxpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Vmaxpu(ctx);
        }
        ILoads& Vmaxpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Vmaxpu(ctx, value);
            return *this;
        }
 
        double Vminemerg() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Vminemerg(ctx);
        }
        ILoads& Vminemerg(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Vminemerg(ctx, value);
            return *this;
        }
 
        double Vminnorm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Vminnorm(ctx);
        }
        ILoads& Vminnorm(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Vminnorm(ctx, value);
            return *this;
        }
 
        double Vminpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Vminpu(ctx);
        }
        ILoads& Vminpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Vminpu(ctx, value);
            return *this;
        }
 
        double Xneut() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Xneut(ctx);
        }
        ILoads& Xneut(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Xneut(ctx, value);
            return *this;
        }
 
        string Yearly() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Yearly(ctx);
        }
        ILoads& Yearly(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Yearly(ctx, value);
            return *this;
        }
        ILoads& Yearly(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Yearly(ctx, value.c_str());
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT ZIPV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Get_ZIPV_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ILoads& ZIPV(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_ZIPV(ctx, &value[0], value.size());
            return *this;
        }
 
        string daily() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_daily(ctx);
        }
        ILoads& daily(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_daily(ctx, value);
            return *this;
        }
        ILoads& daily(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_daily(ctx, value.c_str());
            return *this;
        }
 
        string duty() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_duty(ctx);
        }
        ILoads& duty(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_duty(ctx, value);
            return *this;
        }
        ILoads& duty(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_duty(ctx, value.c_str());
            return *this;
        }
 
        double kV() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_kV(ctx);
        }
        ILoads& kV(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_kV(ctx, value);
            return *this;
        }
 
        double kW() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_kW(ctx);
        }
        ILoads& kW(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_kW(ctx, value);
            return *this;
        }
 
        double kva() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_kva(ctx);
        }
        ILoads& kva(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_kva(ctx, value);
            return *this;
        }
 
        double kvar() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_kvar(ctx);
        }
        ILoads& kvar(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_kvar(ctx, value);
            return *this;
        }
 
        double kwh() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_kwh(ctx);
        }
        ILoads& kwh(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_kwh(ctx, value);
            return *this;
        }
 
        double kwhdays() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_kwhdays(ctx);
        }
        ILoads& kwhdays(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_kwhdays(ctx, value);
            return *this;
        }
 
        double pctSeriesRL() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_pctSeriesRL(ctx);
        }
        ILoads& pctSeriesRL(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_pctSeriesRL(ctx, value);
            return *this;
        }
 
        double xfkVA() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_xfkVA(ctx);
        }
        ILoads& xfkVA(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_xfkVA(ctx, value);
            return *this;
        }
 
        string Sensor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Sensor(ctx);
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Loads_Get_Phases(ctx);
        }
        ILoads& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Loads_Set_Phases(ctx, value);
            return *this;
        }
    };
 
    class ISettings: public ContextState
    {
    public:
 
        ISettings(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        bool AllowDuplicates() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Settings_Get_AllowDuplicates(ctx) != 0);
        }
        ISettings& AllowDuplicates(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_AllowDuplicates(ctx, value);
            return *this;
        }
 
        string AutoBusList() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_AutoBusList(ctx);
        }
        ISettings& AutoBusList(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_AutoBusList(ctx, value);
            return *this;
        }
        ISettings& AutoBusList(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_AutoBusList(ctx, value.c_str());
            return *this;
        }
 
        int32_t CktModel() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_CktModel(ctx);
        }
        ISettings& CktModel(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_CktModel(ctx, value);
            return *this;
        }
 
        bool ControlTrace() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Settings_Get_ControlTrace(ctx) != 0);
        }
        ISettings& ControlTrace(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_ControlTrace(ctx, value);
            return *this;
        }
 
        double EmergVmaxpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_EmergVmaxpu(ctx);
        }
        ISettings& EmergVmaxpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_EmergVmaxpu(ctx, value);
            return *this;
        }
 
        double EmergVminpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_EmergVminpu(ctx);
        }
        ISettings& EmergVminpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_EmergVminpu(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT LossRegs() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Get_LossRegs_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        ISettings& LossRegs(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_LossRegs(ctx, &value[0], value.size());
            return *this;
        }
 
        double LossWeight() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_LossWeight(ctx);
        }
        ISettings& LossWeight(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_LossWeight(ctx, value);
            return *this;
        }
 
        double NormVmaxpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_NormVmaxpu(ctx);
        }
        ISettings& NormVmaxpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_NormVmaxpu(ctx, value);
            return *this;
        }
 
        double NormVminpu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_NormVminpu(ctx);
        }
        ISettings& NormVminpu(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_NormVminpu(ctx, value);
            return *this;
        }
 
        string PriceCurve() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_PriceCurve(ctx);
        }
        ISettings& PriceCurve(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_PriceCurve(ctx, value);
            return *this;
        }
        ISettings& PriceCurve(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_PriceCurve(ctx, value.c_str());
            return *this;
        }
 
        double PriceSignal() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_PriceSignal(ctx);
        }
        ISettings& PriceSignal(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_PriceSignal(ctx, value);
            return *this;
        }
 
        bool Trapezoidal() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Settings_Get_Trapezoidal(ctx) != 0);
        }
        ISettings& Trapezoidal(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_Trapezoidal(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT UEregs() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Get_UEregs_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        ISettings& UEregs(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_UEregs(ctx, &value[0], value.size());
            return *this;
        }
 
        double UEweight() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_UEweight(ctx);
        }
        ISettings& UEweight(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_UEweight(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT VoltageBases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Get_VoltageBases_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        ISettings& VoltageBases(const VectorT &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_VoltageBases(ctx, &value[0], value.size());
            return *this;
        }
 
        bool ZoneLock() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Settings_Get_ZoneLock(ctx) != 0);
        }
        ISettings& ZoneLock(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_ZoneLock(ctx, value);
            return *this;
        }
 
        ISettings& AllocationFactors(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_AllocationFactors(ctx, value);
            return *this;
        }
 
        bool LoadsTerminalCheck() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Settings_Get_LoadsTerminalCheck(ctx) != 0);
        }
        ISettings& LoadsTerminalCheck(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_LoadsTerminalCheck(ctx, value);
            return *this;
        }
 
        int32_t IterateDisabled() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Settings_Get_IterateDisabled(ctx);
        }
        ISettings& IterateDisabled(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Settings_Set_IterateDisabled(ctx, value);
            return *this;
        }
    };
 
    class ICktElement: public ContextState
    {
    public:
        IDSSProperty Properties;
 
        ICktElement(dss::APIUtil *util) :
            ContextState(util),
            Properties(util)
        {
        }
    
        double Variable(const char *MyVarName, int32_t &Code)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_Variable(ctx, MyVarName, &Code);
        }
        double Variable(const string &MyVarName, int32_t &Code)
        {
            return Variable(MyVarName.c_str(), Code);
        }
 
        double Variablei(int32_t Idx, int32_t &Code)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_Variablei(ctx, Idx, &Code);
        }
 
        int32_t setVariableByIndex(int32_t Idx, double Value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            int32_t Code = 0;
            ctx_CktElement_Set_Variablei(ctx, Idx, &Code, Value);
            return Code;
        }
 
        int32_t setVariableByName(const char *name, double Value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            int32_t Code = 0;
            ctx_CktElement_Set_Variable(ctx, name, &Code, Value);
            return Code;
        }
        int32_t setVariableByName(const string &name, double Value)
        {
            return setVariableByName(name.c_str(), Value);
        }
        void Close(int32_t Term, int32_t Phs)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Close(ctx, Term, Phs);
        }
        string Controller(int32_t idx)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_Controller(ctx, idx);
        }
        bool IsOpen(int32_t Term, int32_t Phs)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CktElement_IsOpen(ctx, Term, Phs) != 0);
        }
        void Open(int32_t Term, int32_t Phs)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Open(ctx, Term, Phs);
        }
 
        strings AllPropertyNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_CktElement_Get_AllPropertyNames);
        }
 
        strings AllVariableNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_CktElement_Get_AllVariableNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllVariableValues() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_AllVariableValues_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        strings BusNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_CktElement_Get_BusNames);
        }
        ICktElement& BusNames(const strings &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            api_util->set_string_array(ctx_CktElement_Set_BusNames, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT CplxSeqCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_CplxSeqCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT CplxSeqVoltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_CplxSeqVoltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Currents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_Currents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT CurrentsMagAng() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_CurrentsMagAng_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        string DisplayName() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_DisplayName(ctx);
        }
        ICktElement& DisplayName(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Set_DisplayName(ctx, value);
            return *this;
        }
        ICktElement& DisplayName(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Set_DisplayName(ctx, value.c_str());
            return *this;
        }
 
        double EmergAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_EmergAmps(ctx);
        }
        ICktElement& EmergAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Set_EmergAmps(ctx, value);
            return *this;
        }
 
        bool Enabled() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CktElement_Get_Enabled(ctx) != 0);
        }
        ICktElement& Enabled(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Set_Enabled(ctx, value);
            return *this;
        }
 
        string EnergyMeter() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_EnergyMeter(ctx);
        }
 
        string GUID() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_GUID(ctx);
        }
 
        int32_t Handle() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_Handle(ctx);
        }
 
        bool HasOCPDevice() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CktElement_Get_HasOCPDevice(ctx) != 0);
        }
 
        bool HasSwitchControl() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CktElement_Get_HasSwitchControl(ctx) != 0);
        }
 
        bool HasVoltControl() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CktElement_Get_HasVoltControl(ctx) != 0);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Losses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_Losses_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_Name(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT NodeOrder() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_NodeOrder_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        double NormalAmps() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_NormalAmps(ctx);
        }
        ICktElement& NormalAmps(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Set_NormalAmps(ctx, value);
            return *this;
        }
 
        int32_t NumConductors() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_NumConductors(ctx);
        }
 
        int32_t NumControls() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_NumControls(ctx);
        }
 
        int32_t NumPhases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_NumPhases(ctx);
        }
 
        int32_t NumProperties() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_NumProperties(ctx);
        }
 
        int32_t NumTerminals() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_NumTerminals(ctx);
        }
 
        int32_t OCPDevIndex() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_OCPDevIndex(ctx);
        }
 
        int32_t OCPDevType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_CktElement_Get_OCPDevType(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT PhaseLosses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_PhaseLosses_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Powers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_Powers_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Residuals() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_Residuals_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SeqCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_SeqCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SeqPowers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_SeqPowers_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SeqVoltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_SeqVoltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Voltages() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_Voltages_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT VoltagesMagAng() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_VoltagesMagAng_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Yprim() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_Yprim_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        bool IsIsolated() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_CktElement_Get_IsIsolated(ctx) != 0);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT TotalPowers() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_TotalPowers_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT NodeRef() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_CktElement_Get_NodeRef_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
    };
 
    class IGICSources: public ContextState
    {
    public:
 
        IGICSources(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_GICSources_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Name(ctx);
        }
 
        IGICSources& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Name(ctx, value);
            return *this;
        }
        IGICSources& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_idx(ctx, value);
        }
 
        string Bus1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Bus1(ctx);
        }
 
        string Bus2() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Bus2(ctx);
        }
 
        int32_t Phases() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Phases(ctx);
        }
        IGICSources& Phases(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Phases(ctx, value);
            return *this;
        }
 
        double EN() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_EN(ctx);
        }
        IGICSources& EN(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_EN(ctx, value);
            return *this;
        }
 
        double EE() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_EE(ctx);
        }
        IGICSources& EE(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_EE(ctx, value);
            return *this;
        }
 
        double Lat1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Lat1(ctx);
        }
        IGICSources& Lat1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Lat1(ctx, value);
            return *this;
        }
 
        double Lat2() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Lat2(ctx);
        }
        IGICSources& Lat2(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Lat2(ctx, value);
            return *this;
        }
 
        double Lon1() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Lon1(ctx);
        }
        IGICSources& Lon1(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Lon1(ctx, value);
            return *this;
        }
 
        double Lon2() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Lon2(ctx);
        }
        IGICSources& Lon2(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Lon2(ctx, value);
            return *this;
        }
 
        double Volts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_GICSources_Get_Volts(ctx);
        }
        IGICSources& Volts(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_GICSources_Set_Volts(ctx, value);
            return *this;
        }
    };
 
    class IStorages: public ContextState
    {
    public:
 
        IStorages(dss::APIUtil *util) :
            ContextState(util)
        {
        }
 
        strings AllNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Storages_Get_AllNames);
        }
 
        int32_t Count() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_Count(ctx);
        }
 
        int32_t First() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_First(ctx);
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_Name(ctx);
        }
 
        IStorages& Name(const char *value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Storages_Set_Name(ctx, value);
            return *this;
        }
        IStorages& Name(const string &value)
        {
            return Name(value.c_str());
        }
 
        int32_t Next() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_Next(ctx);
        }
 
        int32_t idx() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_idx(ctx);
        }
 
        void idx(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Storages_Set_idx(ctx, value);
        }
 
        double puSOC() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_puSOC(ctx);
        }
        IStorages& puSOC(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Storages_Set_puSOC(ctx, value);
            return *this;
        }
 
        int32_t State() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Storages_Get_State(ctx);
        }
        IStorages& State(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Storages_Set_State(ctx, value);
            return *this;
        }
 
        strings RegisterNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Storages_Get_RegisterNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT RegisterValues() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Storages_Get_RegisterValues_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
    };
 
    class ISolution: public ContextState
    {
    public:
 
        ISolution(dss::APIUtil *util) :
            ContextState(util)
        {
        }
        void BuildYMatrix(int32_t BuildOption, int32_t AllocateVI)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_BuildYMatrix(ctx, BuildOption, AllocateVI);
        }
        void CheckControls()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_CheckControls(ctx);
        }
        void CheckFaultStatus()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_CheckFaultStatus(ctx);
        }
        void Cleanup()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Cleanup(ctx);
        }
        void DoControlActions()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_DoControlActions(ctx);
        }
        void FinishTimeStep()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_FinishTimeStep(ctx);
        }
        void InitSnap()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_InitSnap(ctx);
        }
        void SampleControlDevices()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_SampleControlDevices(ctx);
        }
        void Sample_DoControlActions()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Sample_DoControlActions(ctx);
        }
        void Solve()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Solve(ctx);
        }
        void SolveDirect()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_SolveDirect(ctx);
        }
        void SolveNoControl()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_SolveNoControl(ctx);
        }
        void SolvePflow()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_SolvePflow(ctx);
        }
        void SolvePlusControl()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_SolvePlusControl(ctx);
        }
        void SolveSnap()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_SolveSnap(ctx);
        }
 
        int32_t AddType() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_AddType(ctx);
        }
        ISolution& AddType(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_AddType(ctx, value);
            return *this;
        }
 
        int32_t Algorithm() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Algorithm(ctx);
        }
        ISolution& Algorithm(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Algorithm(ctx, value);
            return *this;
        }
 
        double Capkvar() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Capkvar(ctx);
        }
        ISolution& Capkvar(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Capkvar(ctx, value);
            return *this;
        }
 
        bool ControlActionsDone() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Solution_Get_ControlActionsDone(ctx) != 0);
        }
        ISolution& ControlActionsDone(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_ControlActionsDone(ctx, value);
            return *this;
        }
 
        int32_t ControlIterations() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_ControlIterations(ctx);
        }
        ISolution& ControlIterations(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_ControlIterations(ctx, value);
            return *this;
        }
 
        int32_t ControlMode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_ControlMode(ctx);
        }
        ISolution& ControlMode(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_ControlMode(ctx, value);
            return *this;
        }
 
        bool Converged() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Solution_Get_Converged(ctx) != 0);
        }
        ISolution& Converged(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Converged(ctx, value);
            return *this;
        }
 
        string DefaultDaily() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_DefaultDaily(ctx);
        }
        ISolution& DefaultDaily(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_DefaultDaily(ctx, value);
            return *this;
        }
        ISolution& DefaultDaily(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_DefaultDaily(ctx, value.c_str());
            return *this;
        }
 
        string DefaultYearly() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_DefaultYearly(ctx);
        }
        ISolution& DefaultYearly(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_DefaultYearly(ctx, value);
            return *this;
        }
        ISolution& DefaultYearly(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_DefaultYearly(ctx, value.c_str());
            return *this;
        }
 
        strings EventLog() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Solution_Get_EventLog);
        }
 
        double Frequency() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Frequency(ctx);
        }
        ISolution& Frequency(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Frequency(ctx, value);
            return *this;
        }
 
        double GenMult() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_GenMult(ctx);
        }
        ISolution& GenMult(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_GenMult(ctx, value);
            return *this;
        }
 
        double GenPF() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_GenPF(ctx);
        }
        ISolution& GenPF(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_GenPF(ctx, value);
            return *this;
        }
 
        double GenkW() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_GenkW(ctx);
        }
        ISolution& GenkW(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_GenkW(ctx, value);
            return *this;
        }
 
        int32_t Hour() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Hour(ctx);
        }
        ISolution& Hour(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Hour(ctx, value);
            return *this;
        }
 
        double IntervalHrs() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_IntervalHrs(ctx);
        }
        ISolution& IntervalHrs(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_IntervalHrs(ctx, value);
            return *this;
        }
 
        int32_t Iterations() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Iterations(ctx);
        }
 
        string LDCurve() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_LDCurve(ctx);
        }
        ISolution& LDCurve(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_LDCurve(ctx, value);
            return *this;
        }
        ISolution& LDCurve(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_LDCurve(ctx, value.c_str());
            return *this;
        }
 
        int32_t LoadModel() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_LoadModel(ctx);
        }
        ISolution& LoadModel(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_LoadModel(ctx, value);
            return *this;
        }
 
        double LoadMult() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_LoadMult(ctx);
        }
        ISolution& LoadMult(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_LoadMult(ctx, value);
            return *this;
        }
 
        int32_t MaxControlIterations() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_MaxControlIterations(ctx);
        }
        ISolution& MaxControlIterations(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_MaxControlIterations(ctx, value);
            return *this;
        }
 
        int32_t MaxIterations() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_MaxIterations(ctx);
        }
        ISolution& MaxIterations(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_MaxIterations(ctx, value);
            return *this;
        }
 
        int32_t MinIterations() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_MinIterations(ctx);
        }
        ISolution& MinIterations(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_MinIterations(ctx, value);
            return *this;
        }
 
        int32_t Mode() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Mode(ctx);
        }
        ISolution& Mode(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Mode(ctx, value);
            return *this;
        }
 
        string ModeID() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_ModeID(ctx);
        }
 
        int32_t MostIterationsDone() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_MostIterationsDone(ctx);
        }
 
        int32_t Number() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Number(ctx);
        }
        ISolution& Number(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Number(ctx, value);
            return *this;
        }
 
        double Process_Time() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Process_Time(ctx);
        }
 
        int32_t Random() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Random(ctx);
        }
        ISolution& Random(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Random(ctx, value);
            return *this;
        }
 
        double Seconds() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Seconds(ctx);
        }
        ISolution& Seconds(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Seconds(ctx, value);
            return *this;
        }
 
        double StepSize() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_StepSize(ctx);
        }
        ISolution& StepSize(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_StepSize(ctx, value);
            return *this;
        }
 
        bool SystemYChanged() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_Solution_Get_SystemYChanged(ctx) != 0);
        }
 
        double Time_of_Step() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Time_of_Step(ctx);
        }
 
        double Tolerance() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Tolerance(ctx);
        }
        ISolution& Tolerance(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Tolerance(ctx, value);
            return *this;
        }
 
        double Total_Time() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Total_Time(ctx);
        }
        ISolution& Total_Time(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Total_Time(ctx, value);
            return *this;
        }
 
        int32_t Totaliterations() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Totaliterations(ctx);
        }
 
        int32_t Year() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_Year(ctx);
        }
        ISolution& Year(int32_t value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_Year(ctx, value);
            return *this;
        }
 
        double dblHour() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_dblHour(ctx);
        }
        ISolution& dblHour(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_dblHour(ctx, value);
            return *this;
        }
 
        double pctGrowth() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Solution_Get_pctGrowth(ctx);
        }
        ISolution& pctGrowth(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_pctGrowth(ctx, value);
            return *this;
        }
 
        ISolution& StepsizeHr(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_StepsizeHr(ctx, value);
            return *this;
        }
 
        ISolution& StepsizeMin(double value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Set_StepsizeMin(ctx, value);
            return *this;
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT BusLevels() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Get_BusLevels_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT IncMatrix() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Get_IncMatrix_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
 
        strings IncMatrixCols() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Solution_Get_IncMatrixCols);
        }
 
        strings IncMatrixRows() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Solution_Get_IncMatrixRows);
        }
 
        template <typename VectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT Laplacian() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Solution_Get_Laplacian_GR(ctx);
            return api_util->get_int32_gr_array<VectorT>();
        }
    };
 
    class ICircuit: public ContextState
    {
    public:
        IBus Buses;
        ICktElement CktElements;
        ICktElement ActiveElement;
        ISolution Solution;
        IBus ActiveBus;
        IGenerators Generators;
        IMeters Meters;
        IMonitors Monitors;
        ISettings Settings;
        ILines Lines;
        ICtrlQueue CtrlQueue;
        ILoads Loads;
        ICktElement ActiveCktElement;
        IDSSElement ActiveDSSElement;
        IActiveClass ActiveClass;
        ICapControls CapControls;
        IRegControls RegControls;
        ISwtControls SwtControls;
        ITransformers Transformers;
        ICapacitors Capacitors;
        ITopology Topology;
        ISensors Sensors;
        IXYCurves XYCurves;
        IPDElements PDElements;
        IReclosers Reclosers;
        IRelays Relays;
        ILoadShapes LoadShapes;
        IFuses Fuses;
        IISources Isources;
        IDSSimComs DSSim_Coms;
        IPVSystems PVSystems;
        IVsources Vsources;
        ILineCodes LineCodes;
        ILineGeometries LineGeometries;
        ILineSpacings LineSpacings;
        IWireData WireData;
        ICNData CNData;
        ITSData TSData;
        IReactors Reactors;
        IReduceCkt ReduceCkt;
        IStorages Storages;
        IGICSources GICSources;
        IParallel Parallel;
 
        ICircuit(dss::APIUtil *util) :
            ContextState(util),
            Buses(util),
            CktElements(util),
            ActiveElement(util),
            Solution(util),
            ActiveBus(util),
            Generators(util),
            Meters(util),
            Monitors(util),
            Settings(util),
            Lines(util),
            CtrlQueue(util),
            Loads(util),
            ActiveCktElement(util),
            ActiveDSSElement(util),
            ActiveClass(util),
            CapControls(util),
            RegControls(util),
            SwtControls(util),
            Transformers(util),
            Capacitors(util),
            Topology(util),
            Sensors(util),
            XYCurves(util),
            PDElements(util),
            Reclosers(util),
            Relays(util),
            LoadShapes(util),
            Fuses(util),
            Isources(util),
            DSSim_Coms(util),
            PVSystems(util),
            Vsources(util),
            LineCodes(util),
            LineGeometries(util),
            LineSpacings(util),
            WireData(util),
            CNData(util),
            TSData(util),
            Reactors(util),
            ReduceCkt(util),
            Storages(util),
            GICSources(util),
            Parallel(util)
        {
        }
    
        IBus& get_Buses(int32_t idx)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            if (ctx_Circuit_SetActiveBusi(ctx, idx) < 0)
                throw std::runtime_error("Invalid bus");
        
            return ActiveBus;
        }
 
        IBus& get_Buses(const char *name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            if (ctx_Circuit_SetActiveBus(ctx, name) < 0)
                throw std::runtime_error("Invalid bus");
 
            return ActiveBus;
        }
        IBus& get_Buses(const string &name)
        {
            return get_Buses(name.c_str());
        }
 
        ICktElement get_CktElements(int32_t idx)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_SetCktElementIndex(ctx, idx);
            return ActiveCktElement;
        }
 
        ICktElement get_CktElements(const char *fullName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_SetCktElementName(ctx, fullName);
            return ActiveCktElement;
        }
        ICktElement get_CktElements(const string &fullName)
        {
            return get_CktElements(fullName.c_str());
        }
        double Capacity(double Start, double Increment)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_Capacity(ctx, Start, Increment);
        }
        void Disable(const char *Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Disable(ctx, Name);
        }
        void Disable(const string &Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Disable(ctx, Name.c_str());
        }
        void Enable(const char *Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Enable(ctx, Name);
        }
        void Enable(const string &Name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Enable(ctx, Name.c_str());
        }
        void EndOfTimeStepUpdate()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_EndOfTimeStepUpdate(ctx);
        }
        int32_t FirstElement()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_FirstElement(ctx);
        }
        int32_t FirstPCElement()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_FirstPCElement(ctx);
        }
        int32_t FirstPDElement()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_FirstPDElement(ctx);
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllNodeDistancesByPhase(int32_t Phase)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllNodeDistancesByPhase_GR(ctx, Phase);
            return api_util->get_float64_gr_array<VectorT>();
        }
        strings AllNodeNamesByPhase(int32_t Phase)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Circuit_Get_AllNodeNamesByPhase, Phase);
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllNodeVmagByPhase(int32_t Phase)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllNodeVmagByPhase_GR(ctx, Phase);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllNodeVmagPUByPhase(int32_t Phase)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllNodeVmagPUByPhase_GR(ctx, Phase);
            return api_util->get_float64_gr_array<VectorT>();
        }
        int32_t NextElement()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_NextElement(ctx);
        }
        int32_t NextPCElement()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_NextPCElement(ctx);
        }
        int32_t NextPDElement()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_NextPDElement(ctx);
        }
        void Sample()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Sample(ctx);
        }
        void SaveSample()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_SaveSample(ctx);
        }
        int32_t SetActiveBus(const char *BusName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveBus(ctx, BusName);
        }
        int32_t SetActiveBus(const string &BusName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveBus(ctx, BusName.c_str());
        }
        int32_t SetActiveBusi(int32_t BusIndex)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveBusi(ctx, BusIndex);
        }
        int32_t SetActiveClass(const char *ClassName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveClass(ctx, ClassName);
        }
        int32_t SetActiveClass(const string &ClassName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveClass(ctx, ClassName.c_str());
        }
        int32_t SetActiveElement(const char *FullName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveElement(ctx, FullName);
        }
        int32_t SetActiveElement(const string &FullName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_SetActiveElement(ctx, FullName.c_str());
        }
        void UpdateStorage()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_UpdateStorage(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllBusDistances() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllBusDistances_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        strings AllBusNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Circuit_Get_AllBusNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllBusVmag() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllBusVmag_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllBusVmagPu() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllBusVmagPu_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllBusVolts() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllBusVolts_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllElementLosses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllElementLosses_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        strings AllElementNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Circuit_Get_AllElementNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT AllNodeDistances() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_AllNodeDistances_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        strings AllNodeNames() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Circuit_Get_AllNodeNames);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT LineLosses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_LineLosses_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT Losses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_Losses_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        string Name() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_Get_Name(ctx);
        }
 
        int32_t NumBuses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_Get_NumBuses(ctx);
        }
 
        int32_t NumCktElements() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_Get_NumCktElements(ctx);
        }
 
        int32_t NumNodes() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_Get_NumNodes(ctx);
        }
 
        int32_t ParentPDElement() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_Circuit_Get_ParentPDElement(ctx);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SubstationLosses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_SubstationLosses_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT SystemY() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_SystemY_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT TotalPower() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_TotalPower_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT YCurrents() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_YCurrents_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
 
        strings YNodeOrder() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_Circuit_Get_YNodeOrder);
        }
 
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>>
        VectorT YNodeVarray() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_YNodeVarray_GR(ctx);
            return api_util->get_float64_gr_array<VectorT>();
        }
        template <typename VectorT=Eigen::Matrix<double, Eigen::Dynamic, 1>, typename InVectorT=Eigen::Matrix<int32_t, Eigen::Dynamic, 1>>
        VectorT ElementLosses(const InVectorT &value)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_Circuit_Get_ElementLosses_GR(ctx, &value[0], value.size());
            return api_util->get_float64_gr_array<VectorT>();
        }
    };
 
    class IDSS: public ContextState
    {
    public:
        ICircuit ActiveCircuit;
        ICircuit Circuits;
        IError Error;
        IText Text;
        IDSSProgress DSSProgress;
        IActiveClass ActiveClass;
        IDSS_Executive Executive;
        IParser Parser;
        IDSSimComs DSSim_Coms;
        IYMatrix YMatrix;
        IZIP ZIP;
        bool owns_util;
 
        IDSS(dss::APIUtil *util, bool owns=false) :
            ContextState(util),
            ActiveCircuit(util),
            Circuits(util),
            Error(util),
            Text(util),
            DSSProgress(util),
            ActiveClass(util),
            Executive(util),
            Parser(util),
            DSSim_Coms(util),
            YMatrix(util),
            ZIP(util),
            owns_util(owns)
        {
        }
    
        IDSS(): IDSS(new APIUtil(ctx_Get_Prime()))
        {
        }
 
        static IDSS *NewContext()
        {
            APIUtil *new_api_util = new APIUtil(ctx_New());
            return new IDSS(new_api_util, true);
        }
    
        ~IDSS()
        {
            if (owns_util)
            {
                delete api_util;
            }
        }
    
        void ClearAll()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_ClearAll(ctx);
        }
        void Reset()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Reset(ctx);
        }
        int32_t SetActiveClass(const char *ClassName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_SetActiveClass(ctx, ClassName);
        }
        int32_t SetActiveClass(const string &ClassName)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_SetActiveClass(ctx, ClassName.c_str());
        }
        bool Start(int32_t code)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Start(ctx, code) != 0);
        }
 
        strings Classes() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_DSS_Get_Classes);
        }
 
        string DataPath() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Get_DataPath(ctx);
        }
        IDSS& DataPath(const char *value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_DataPath(ctx, value);
            return *this;
        }
        IDSS& DataPath(const string &value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_DataPath(ctx, value.c_str());
            return *this;
        }
 
        string DefaultEditor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Get_DefaultEditor(ctx);
        }
 
        int32_t NumCircuits() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Get_NumCircuits(ctx);
        }
 
        int32_t NumClasses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Get_NumClasses(ctx);
        }
 
        int32_t NumUserClasses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Get_NumUserClasses(ctx);
        }
 
        strings UserClasses() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return api_util->get_string_array(ctx_DSS_Get_UserClasses);
        }
 
        string Version() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return ctx_DSS_Get_Version(ctx);
        }
 
        bool AllowForms() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Get_AllowForms(ctx) != 0);
        }
        IDSS& AllowForms(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_AllowForms(ctx, value);
            return *this;
        }
 
        bool AllowEditor() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Get_AllowEditor(ctx) != 0);
        }
        IDSS& AllowEditor(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_AllowEditor(ctx, value);
            return *this;
        }
        void ShowPanel()
        {
            APIUtil::ErrorChecker error_checker(api_util);
            // #warning ("ShowPanel is not implemented.");
        }
        ICircuit& NewCircuit(const char *name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_NewCircuit(ctx, name);
            return ActiveCircuit;
        }
        ICircuit& NewCircuit(const string &name)
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_NewCircuit(ctx, name.c_str());
            return ActiveCircuit;
        }
 
        bool LegacyModels() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Get_LegacyModels(ctx) != 0);
        }
        IDSS& LegacyModels(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_LegacyModels(ctx, value);
            return *this;
        }
 
        bool AllowChangeDir() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Get_AllowChangeDir(ctx) != 0);
        }
        IDSS& AllowChangeDir(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_AllowChangeDir(ctx, value);
            return *this;
        }
 
        bool AllowDOScmd() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Get_AllowDOScmd(ctx) != 0);
        }
        IDSS& AllowDOScmd(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_AllowDOScmd(ctx, value);
            return *this;
        }
 
        bool COMErrorResults() // getter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            return (ctx_DSS_Get_COMErrorResults(ctx) != 0);
        }
        IDSS& COMErrorResults(bool value) // setter
        {
            APIUtil::ErrorChecker error_checker(api_util);
            ctx_DSS_Set_COMErrorResults(ctx, value);
            return *this;
        }
 
    };
 
} } // namespace dss::classic
#endif // #ifndef DSS_CPP_CLASSIC_API