# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

import _fmippim

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fmippim.delete_SwigPyIterator

    def value(self):
        return _fmippim.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _fmippim.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _fmippim.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _fmippim.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _fmippim.SwigPyIterator_equal(self, x)

    def copy(self):
        return _fmippim.SwigPyIterator_copy(self)

    def next(self):
        return _fmippim.SwigPyIterator_next(self)

    def __next__(self):
        return _fmippim.SwigPyIterator___next__(self)

    def previous(self):
        return _fmippim.SwigPyIterator_previous(self)

    def advance(self, n):
        return _fmippim.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _fmippim.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _fmippim.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _fmippim.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _fmippim.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _fmippim.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _fmippim.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _fmippim:
_fmippim.SwigPyIterator_swigregister(SwigPyIterator)


def new_double_pointer():
    return _fmippim.new_double_pointer()

def copy_double_pointer(value):
    return _fmippim.copy_double_pointer(value)

def delete_double_pointer(obj):
    return _fmippim.delete_double_pointer(obj)

def double_pointer_assign(obj, value):
    return _fmippim.double_pointer_assign(obj, value)

def double_pointer_value(obj):
    return _fmippim.double_pointer_value(obj)

def new_int_pointer():
    return _fmippim.new_int_pointer()

def copy_int_pointer(value):
    return _fmippim.copy_int_pointer(value)

def delete_int_pointer(obj):
    return _fmippim.delete_int_pointer(obj)

def int_pointer_assign(obj, value):
    return _fmippim.int_pointer_assign(obj, value)

def int_pointer_value(obj):
    return _fmippim.int_pointer_value(obj)

def new_string_pointer():
    return _fmippim.new_string_pointer()

def copy_string_pointer(value):
    return _fmippim.copy_string_pointer(value)

def delete_string_pointer(obj):
    return _fmippim.delete_string_pointer(obj)

def string_pointer_assign(obj, value):
    return _fmippim.string_pointer_assign(obj, value)

def string_pointer_value(obj):
    return _fmippim.string_pointer_value(obj)

def new_bool_pointer():
    return _fmippim.new_bool_pointer()

def copy_bool_pointer(value):
    return _fmippim.copy_bool_pointer(value)

def delete_bool_pointer(obj):
    return _fmippim.delete_bool_pointer(obj)

def bool_pointer_assign(obj, value):
    return _fmippim.bool_pointer_assign(obj, value)

def bool_pointer_value(obj):
    return _fmippim.bool_pointer_value(obj)

def new_double_array(nelements):
    return _fmippim.new_double_array(nelements)

def delete_double_array(ary):
    return _fmippim.delete_double_array(ary)

def double_array_getitem(ary, index):
    return _fmippim.double_array_getitem(ary, index)

def double_array_setitem(ary, index, value):
    return _fmippim.double_array_setitem(ary, index, value)

def new_int_array(nelements):
    return _fmippim.new_int_array(nelements)

def delete_int_array(ary):
    return _fmippim.delete_int_array(ary)

def int_array_getitem(ary, index):
    return _fmippim.int_array_getitem(ary, index)

def int_array_setitem(ary, index, value):
    return _fmippim.int_array_setitem(ary, index, value)

def new_string_array(nelements):
    return _fmippim.new_string_array(nelements)

def delete_string_array(ary):
    return _fmippim.delete_string_array(ary)

def string_array_getitem(ary, index):
    return _fmippim.string_array_getitem(ary, index)

def string_array_setitem(ary, index, value):
    return _fmippim.string_array_setitem(ary, index, value)

def new_bool_array(nelements):
    return _fmippim.new_bool_array(nelements)

def delete_bool_array(ary):
    return _fmippim.delete_bool_array(ary)

def bool_array_getitem(ary, index):
    return _fmippim.bool_array_getitem(ary, index)

def bool_array_setitem(ary, index, value):
    return _fmippim.bool_array_setitem(ary, index, value)
class StringVector(object):
    r"""Proxy of C++ std::vector< std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _fmippim.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _fmippim.StringVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _fmippim.StringVector___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::string >::size_type"""
        return _fmippim.StringVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(self, i, j) -> StringVector"""
        return _fmippim.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)
        __setslice__(self, i, j, v)
        """
        return _fmippim.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(self, i, j)"""
        return _fmippim.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _fmippim.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> StringVector
        __getitem__(self, i) -> std::vector< std::string >::value_type const &
        """
        return _fmippim.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)
        __setitem__(self, slice)
        __setitem__(self, i, x)
        """
        return _fmippim.StringVector___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< std::string >::value_type"""
        return _fmippim.StringVector_pop(self)

    def append(self, x):
        r"""append(self, x)"""
        return _fmippim.StringVector_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _fmippim.StringVector_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::string >::size_type"""
        return _fmippim.StringVector_size(self)

    def swap(self, v):
        r"""swap(self, v)"""
        return _fmippim.StringVector_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::string >::iterator"""
        return _fmippim.StringVector_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::string >::iterator"""
        return _fmippim.StringVector_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::string >::reverse_iterator"""
        return _fmippim.StringVector_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::string >::reverse_iterator"""
        return _fmippim.StringVector_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _fmippim.StringVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::string >::allocator_type"""
        return _fmippim.StringVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _fmippim.StringVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::string >::iterator
        erase(self, first, last) -> std::vector< std::string >::iterator
        """
        return _fmippim.StringVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> StringVector
        __init__(self, other) -> StringVector
        __init__(self, size) -> StringVector
        __init__(self, size, value) -> StringVector
        """
        _fmippim.StringVector_swiginit(self, _fmippim.new_StringVector(*args))

    def push_back(self, x):
        r"""push_back(self, x)"""
        return _fmippim.StringVector_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< std::string >::value_type const &"""
        return _fmippim.StringVector_front(self)

    def back(self):
        r"""back(self) -> std::vector< std::string >::value_type const &"""
        return _fmippim.StringVector_back(self)

    def assign(self, n, x):
        r"""assign(self, n, x)"""
        return _fmippim.StringVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _fmippim.StringVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::string >::iterator
        insert(self, pos, n, x)
        """
        return _fmippim.StringVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(self, n)"""
        return _fmippim.StringVector_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::string >::size_type"""
        return _fmippim.StringVector_capacity(self)
    __swig_destroy__ = _fmippim.delete_StringVector

# Register StringVector in _fmippim:
_fmippim.StringVector_swigregister(StringVector)

class UnsignedIntVector(object):
    r"""Proxy of C++ std::vector< unsigned int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _fmippim.UnsignedIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _fmippim.UnsignedIntVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _fmippim.UnsignedIntVector___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< unsigned int >::size_type"""
        return _fmippim.UnsignedIntVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(self, i, j) -> UnsignedIntVector"""
        return _fmippim.UnsignedIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)
        __setslice__(self, i, j, v)
        """
        return _fmippim.UnsignedIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(self, i, j)"""
        return _fmippim.UnsignedIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _fmippim.UnsignedIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> UnsignedIntVector
        __getitem__(self, i) -> std::vector< unsigned int >::value_type const &
        """
        return _fmippim.UnsignedIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)
        __setitem__(self, slice)
        __setitem__(self, i, x)
        """
        return _fmippim.UnsignedIntVector___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< unsigned int >::value_type"""
        return _fmippim.UnsignedIntVector_pop(self)

    def append(self, x):
        r"""append(self, x)"""
        return _fmippim.UnsignedIntVector_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _fmippim.UnsignedIntVector_empty(self)

    def size(self):
        r"""size(self) -> std::vector< unsigned int >::size_type"""
        return _fmippim.UnsignedIntVector_size(self)

    def swap(self, v):
        r"""swap(self, v)"""
        return _fmippim.UnsignedIntVector_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< unsigned int >::iterator"""
        return _fmippim.UnsignedIntVector_begin(self)

    def end(self):
        r"""end(self) -> std::vector< unsigned int >::iterator"""
        return _fmippim.UnsignedIntVector_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< unsigned int >::reverse_iterator"""
        return _fmippim.UnsignedIntVector_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< unsigned int >::reverse_iterator"""
        return _fmippim.UnsignedIntVector_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _fmippim.UnsignedIntVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< unsigned int >::allocator_type"""
        return _fmippim.UnsignedIntVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _fmippim.UnsignedIntVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< unsigned int >::iterator
        erase(self, first, last) -> std::vector< unsigned int >::iterator
        """
        return _fmippim.UnsignedIntVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> UnsignedIntVector
        __init__(self, other) -> UnsignedIntVector
        __init__(self, size) -> UnsignedIntVector
        __init__(self, size, value) -> UnsignedIntVector
        """
        _fmippim.UnsignedIntVector_swiginit(self, _fmippim.new_UnsignedIntVector(*args))

    def push_back(self, x):
        r"""push_back(self, x)"""
        return _fmippim.UnsignedIntVector_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< unsigned int >::value_type const &"""
        return _fmippim.UnsignedIntVector_front(self)

    def back(self):
        r"""back(self) -> std::vector< unsigned int >::value_type const &"""
        return _fmippim.UnsignedIntVector_back(self)

    def assign(self, n, x):
        r"""assign(self, n, x)"""
        return _fmippim.UnsignedIntVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _fmippim.UnsignedIntVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< unsigned int >::iterator
        insert(self, pos, n, x)
        """
        return _fmippim.UnsignedIntVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(self, n)"""
        return _fmippim.UnsignedIntVector_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< unsigned int >::size_type"""
        return _fmippim.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _fmippim.delete_UnsignedIntVector

# Register UnsignedIntVector in _fmippim:
_fmippim.UnsignedIntVector_swigregister(UnsignedIntVector)

typeReal = _fmippim.typeReal

typeInteger = _fmippim.typeInteger

typeBoolean = _fmippim.typeBoolean

typeString = _fmippim.typeString

typeUnknown = _fmippim.typeUnknown

statusOK = _fmippim.statusOK

statusWarning = _fmippim.statusWarning

statusDiscard = _fmippim.statusDiscard

statusError = _fmippim.statusError

statusFatal = _fmippim.statusFatal

clockActive = _fmippim.clockActive

clockInactive = _fmippim.clockInactive

invalid = _fmippim.invalid

fmuTypeME1 = _fmippim.fmuTypeME1

fmuTypeCS1 = _fmippim.fmuTypeCS1

fmuTypeME2 = _fmippim.fmuTypeME2

fmuTypeCS2 = _fmippim.fmuTypeCS2

fmuTypeMEAndCS2 = _fmippim.fmuTypeMEAndCS2

class FMUModelExchangeV1(object):
    r"""Proxy of C++ fmi_1_0::FMUModelExchange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        FMUModelExchange(fmuDirUri, modelIdentifier, loggingOn=False, stopBeforeEvent=False, eventSearchPrecision=1e-4, type=IntegratorType::bdf) -> FMUModelExchangeV1
        FMUModelExchange(modelIdentifier, loggingOn=False, stopBeforeEvent=False, eventSearchPrecision=1e-4, type=IntegratorType::bdf) -> FMUModelExchangeV1
        __init__(self, aFMU) -> FMUModelExchangeV1
        """
        _fmippim.FMUModelExchangeV1_swiginit(self, _fmippim.new_FMUModelExchangeV1(*args))
    __swig_destroy__ = _fmippim.delete_FMUModelExchangeV1

    def instantiate(self, instanceName):
        r"""instantiate(self, instanceName) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_instantiate(self, instanceName)

    def initialize(self, toleranceDefined=False, tolerance=1e-5):
        r"""initialize(self, toleranceDefined=False, tolerance=1e-5) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_initialize(self, toleranceDefined, tolerance)

    def getContinuousStates(self, val):
        r"""getContinuousStates(self, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_getContinuousStates(self, val)

    def setContinuousStates(self, val):
        r"""setContinuousStates(self, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setContinuousStates(self, val)

    def getDerivatives(self, val):
        r"""getDerivatives(self, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_getDerivatives(self, val)

    def getEventIndicators(self, eventsind):
        r"""getEventIndicators(self, eventsind) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_getEventIndicators(self, eventsind)

    def integrateN(self, tend, nsteps):
        r"""integrateN(self, tend, nsteps) -> fmippTime"""
        return _fmippim.FMUModelExchangeV1_integrateN(self, tend, nsteps)

    def integrate(self, tend, deltaT=1e-5):
        r"""integrate(self, tend, deltaT=1e-5) -> fmippTime"""
        return _fmippim.FMUModelExchangeV1_integrate(self, tend, deltaT)

    def stepOverEvent(self):
        r"""stepOverEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_stepOverEvent(self)

    def completedIntegratorStep(self):
        r"""completedIntegratorStep(self) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_completedIntegratorStep(self)

    def getEventFlag(self):
        r"""getEventFlag(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_getEventFlag(self)

    def setEventFlag(self, flag):
        r"""setEventFlag(self, flag)"""
        return _fmippim.FMUModelExchangeV1_setEventFlag(self, flag)

    def resetEventFlags(self):
        r"""resetEventFlags(self)"""
        return _fmippim.FMUModelExchangeV1_resetEventFlags(self)

    def getIntEvent(self):
        r"""getIntEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_getIntEvent(self)

    def getTimeEvent(self):
        r"""getTimeEvent(self) -> fmippTime"""
        return _fmippim.FMUModelExchangeV1_getTimeEvent(self)

    def raiseEvent(self):
        r"""raiseEvent(self)"""
        return _fmippim.FMUModelExchangeV1_raiseEvent(self)

    def checkEvents(self):
        r"""checkEvents(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_checkEvents(self)

    def checkStateEvent(self):
        r"""checkStateEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_checkStateEvent(self)

    def checkTimeEvent(self):
        r"""checkTimeEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_checkTimeEvent(self)

    def checkStepEvent(self):
        r"""checkStepEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_checkStepEvent(self)

    def handleEvents(self):
        r"""handleEvents(self)"""
        return _fmippim.FMUModelExchangeV1_handleEvents(self)

    def setTime(self, time):
        r"""setTime(self, time) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setTime(self, time)

    def rewindTime(self, deltaRewindTime):
        r"""rewindTime(self, deltaRewindTime)"""
        return _fmippim.FMUModelExchangeV1_rewindTime(self, deltaRewindTime)

    def getTime(self):
        r"""getTime(self) -> fmippTime"""
        return _fmippim.FMUModelExchangeV1_getTime(self)

    def getType(self, variableName):
        r"""getType(self, variableName) -> FMIPPVariableType"""
        return _fmippim.FMUModelExchangeV1_getType(self, variableName)

    def getValueRef(self, name):
        r"""getValueRef(self, name) -> fmippValueReference"""
        return _fmippim.FMUModelExchangeV1_getValueRef(self, name)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_getLastStatus(self)

    def getRealValue(self, name):
        r"""getRealValue(self, name) -> fmippReal"""
        return _fmippim.FMUModelExchangeV1_getRealValue(self, name)

    def getIntegerValue(self, name):
        r"""getIntegerValue(self, name) -> fmippInteger"""
        return _fmippim.FMUModelExchangeV1_getIntegerValue(self, name)

    def getBooleanValue(self, name):
        r"""getBooleanValue(self, name) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV1_getBooleanValue(self, name)

    def getStringValue(self, name):
        r"""getStringValue(self, name) -> fmippString"""
        return _fmippim.FMUModelExchangeV1_getStringValue(self, name)

    def setRealValue(self, name, val):
        r"""setRealValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setRealValue(self, name, val)

    def setIntegerValue(self, name, val):
        r"""setIntegerValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setIntegerValue(self, name, val)

    def setBooleanValue(self, name, val):
        r"""setBooleanValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setBooleanValue(self, name, val)

    def setStringValue(self, name, val):
        r"""setStringValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setStringValue(self, name, val)

    def nStates(self):
        r"""nStates(self) -> fmippSize"""
        return _fmippim.FMUModelExchangeV1_nStates(self)

    def nEventInds(self):
        r"""nEventInds(self) -> fmippSize"""
        return _fmippim.FMUModelExchangeV1_nEventInds(self)

    def nValueRefs(self):
        r"""nValueRefs(self) -> fmippSize"""
        return _fmippim.FMUModelExchangeV1_nValueRefs(self)

    def sendDebugMessage(self, msg):
        r"""sendDebugMessage(self, msg)"""
        return _fmippim.FMUModelExchangeV1_sendDebugMessage(self, msg)

    def logger(self, *args):
        r"""
        logger(self, status, category, msg)
        logger(self, status, category, msg)
        """
        return _fmippim.FMUModelExchangeV1_logger(self, *args)

    def getEventSearchPrecision(self):
        r"""getEventSearchPrecision(self) -> fmippTime"""
        return _fmippim.FMUModelExchangeV1_getEventSearchPrecision(self)

    def setCallbacks(self, logger, allocateMemory, freeMemory):
        r"""setCallbacks(self, logger, allocateMemory, freeMemory) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV1_setCallbacks(self, logger, allocateMemory, freeMemory)

# Register FMUModelExchangeV1 in _fmippim:
_fmippim.FMUModelExchangeV1_swigregister(FMUModelExchangeV1)

class FMUModelExchangeV2(object):
    r"""Proxy of C++ fmi_2_0::FMUModelExchange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        FMUModelExchange(fmuDirUri, modelIdentifier, loggingOn=False, stopBeforeEvent=False, eventSearchPrecision=1e-4, type=IntegratorType::bdf) -> FMUModelExchangeV2
        FMUModelExchange(modelIdentifier, loggingOn=False, stopBeforeEvent=False, eventSearchPrecision=1e-4, type=IntegratorType::bdf) -> FMUModelExchangeV2
        __init__(self, aFMU) -> FMUModelExchangeV2
        """
        _fmippim.FMUModelExchangeV2_swiginit(self, _fmippim.new_FMUModelExchangeV2(*args))
    __swig_destroy__ = _fmippim.delete_FMUModelExchangeV2

    def instantiate(self, instanceName):
        r"""instantiate(self, instanceName) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_instantiate(self, instanceName)

    def initialize(self, toleranceDefined=False, tolerance=1e-5):
        r"""initialize(self, toleranceDefined=False, tolerance=1e-5) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_initialize(self, toleranceDefined, tolerance)

    def getContinuousStates(self, val):
        r"""getContinuousStates(self, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_getContinuousStates(self, val)

    def setContinuousStates(self, val):
        r"""setContinuousStates(self, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setContinuousStates(self, val)

    def getDerivatives(self, val):
        r"""getDerivatives(self, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_getDerivatives(self, val)

    def getDerivativesRefs(self):
        r"""getDerivativesRefs(self) -> UnsignedIntVector"""
        return _fmippim.FMUModelExchangeV2_getDerivativesRefs(self)

    def getDerivativesNames(self):
        r"""getDerivativesNames(self) -> StringVector"""
        return _fmippim.FMUModelExchangeV2_getDerivativesNames(self)

    def getJac(self, J):
        r"""getJac(self, J) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_getJac(self, J)

    def getEventIndicators(self, eventsind):
        r"""getEventIndicators(self, eventsind) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_getEventIndicators(self, eventsind)

    def integrateN(self, tend, nsteps):
        r"""integrateN(self, tend, nsteps) -> fmippTime"""
        return _fmippim.FMUModelExchangeV2_integrateN(self, tend, nsteps)

    def integrate(self, tend, deltaT=1e-5):
        r"""integrate(self, tend, deltaT=1e-5) -> fmippTime"""
        return _fmippim.FMUModelExchangeV2_integrate(self, tend, deltaT)

    def handleEvents(self):
        r"""handleEvents(self)"""
        return _fmippim.FMUModelExchangeV2_handleEvents(self)

    def completedIntegratorStep(self):
        r"""completedIntegratorStep(self) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_completedIntegratorStep(self)

    def getEventFlag(self):
        r"""getEventFlag(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_getEventFlag(self)

    def setEventFlag(self, flag):
        r"""setEventFlag(self, flag)"""
        return _fmippim.FMUModelExchangeV2_setEventFlag(self, flag)

    def resetEventFlags(self):
        r"""resetEventFlags(self)"""
        return _fmippim.FMUModelExchangeV2_resetEventFlags(self)

    def getIntEvent(self):
        r"""getIntEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_getIntEvent(self)

    def getTimeEvent(self):
        r"""getTimeEvent(self) -> fmippReal"""
        return _fmippim.FMUModelExchangeV2_getTimeEvent(self)

    def raiseEvent(self):
        r"""raiseEvent(self)"""
        return _fmippim.FMUModelExchangeV2_raiseEvent(self)

    def checkEvents(self):
        r"""checkEvents(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_checkEvents(self)

    def checkStateEvent(self):
        r"""checkStateEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_checkStateEvent(self)

    def checkTimeEvent(self):
        r"""checkTimeEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_checkTimeEvent(self)

    def checkStepEvent(self):
        r"""checkStepEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_checkStepEvent(self)

    def setTime(self, time):
        r"""setTime(self, time) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setTime(self, time)

    def rewindTime(self, deltaRewindTime):
        r"""rewindTime(self, deltaRewindTime)"""
        return _fmippim.FMUModelExchangeV2_rewindTime(self, deltaRewindTime)

    def getTime(self):
        r"""getTime(self) -> fmippTime"""
        return _fmippim.FMUModelExchangeV2_getTime(self)

    def getType(self, variableName):
        r"""getType(self, variableName) -> FMIPPVariableType"""
        return _fmippim.FMUModelExchangeV2_getType(self, variableName)

    def getValueRef(self, name):
        r"""getValueRef(self, name) -> fmippValueReference"""
        return _fmippim.FMUModelExchangeV2_getValueRef(self, name)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_getLastStatus(self)

    def getRealValue(self, name):
        r"""getRealValue(self, name) -> fmippReal"""
        return _fmippim.FMUModelExchangeV2_getRealValue(self, name)

    def getIntegerValue(self, name):
        r"""getIntegerValue(self, name) -> fmippInteger"""
        return _fmippim.FMUModelExchangeV2_getIntegerValue(self, name)

    def getBooleanValue(self, name):
        r"""getBooleanValue(self, name) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_getBooleanValue(self, name)

    def getStringValue(self, name):
        r"""getStringValue(self, name) -> fmippString"""
        return _fmippim.FMUModelExchangeV2_getStringValue(self, name)

    def setRealValue(self, name, val):
        r"""setRealValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setRealValue(self, name, val)

    def setIntegerValue(self, name, val):
        r"""setIntegerValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setIntegerValue(self, name, val)

    def setBooleanValue(self, name, val):
        r"""setBooleanValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setBooleanValue(self, name, val)

    def setStringValue(self, name, val):
        r"""setStringValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setStringValue(self, name, val)

    def nStates(self):
        r"""nStates(self) -> fmippSize"""
        return _fmippim.FMUModelExchangeV2_nStates(self)

    def getStatesRefs(self):
        r"""getStatesRefs(self) -> UnsignedIntVector"""
        return _fmippim.FMUModelExchangeV2_getStatesRefs(self)

    def getStatesNames(self):
        r"""getStatesNames(self) -> StringVector"""
        return _fmippim.FMUModelExchangeV2_getStatesNames(self)

    def nEventInds(self):
        r"""nEventInds(self) -> fmippSize"""
        return _fmippim.FMUModelExchangeV2_nEventInds(self)

    def nValueRefs(self):
        r"""nValueRefs(self) -> fmippSize"""
        return _fmippim.FMUModelExchangeV2_nValueRefs(self)

    def sendDebugMessage(self, msg):
        r"""sendDebugMessage(self, msg)"""
        return _fmippim.FMUModelExchangeV2_sendDebugMessage(self, msg)

    def logger(self, *args):
        r"""
        logger(self, status, category, msg)
        logger(self, status, category, msg)
        """
        return _fmippim.FMUModelExchangeV2_logger(self, *args)

    def getEventSearchPrecision(self):
        r"""getEventSearchPrecision(self) -> fmippReal"""
        return _fmippim.FMUModelExchangeV2_getEventSearchPrecision(self)

    def setCallbacks(self, logger, allocateMemory, freeMemory):
        r"""setCallbacks(self, logger, allocateMemory, freeMemory) -> fmippStatus"""
        return _fmippim.FMUModelExchangeV2_setCallbacks(self, logger, allocateMemory, freeMemory)

    def setComponentEnvironment(self, env):
        r"""setComponentEnvironment(self, env)"""
        return _fmippim.FMUModelExchangeV2_setComponentEnvironment(self, env)

    def stepOverEvent(self):
        r"""stepOverEvent(self) -> fmippBoolean"""
        return _fmippim.FMUModelExchangeV2_stepOverEvent(self)

# Register FMUModelExchangeV2 in _fmippim:
_fmippim.FMUModelExchangeV2_swigregister(FMUModelExchangeV2)

class FMUCoSimulationV1(object):
    r"""Proxy of C++ fmi_1_0::FMUCoSimulation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        FMUCoSimulation(fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-9) -> FMUCoSimulationV1
        FMUCoSimulation(modelIdentifier, loggingOn=False, timeDiffResolution=1e-9) -> FMUCoSimulationV1
        __init__(self, fmu) -> FMUCoSimulationV1
        """
        _fmippim.FMUCoSimulationV1_swiginit(self, _fmippim.new_FMUCoSimulationV1(*args))
    __swig_destroy__ = _fmippim.delete_FMUCoSimulationV1

    def terminate(self):
        r"""terminate(self)"""
        return _fmippim.FMUCoSimulationV1_terminate(self)

    def instantiate(self, instanceName, timeout, visible, interactive):
        r"""instantiate(self, instanceName, timeout, visible, interactive) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_instantiate(self, instanceName, timeout, visible, interactive)

    def initialize(self, startTime, stopTimeDefined, stopTime):
        r"""initialize(self, startTime, stopTimeDefined, stopTime) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_initialize(self, startTime, stopTimeDefined, stopTime)

    def doStep(self, currentCommunicationPoint, communicationStepSize, newStep):
        r"""doStep(self, currentCommunicationPoint, communicationStepSize, newStep) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_doStep(self, currentCommunicationPoint, communicationStepSize, newStep)

    def getTime(self):
        r"""getTime(self) -> fmippReal"""
        return _fmippim.FMUCoSimulationV1_getTime(self)

    def setRealValue(self, name, val):
        r"""setRealValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_setRealValue(self, name, val)

    def setIntegerValue(self, name, val):
        r"""setIntegerValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_setIntegerValue(self, name, val)

    def setBooleanValue(self, name, val):
        r"""setBooleanValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_setBooleanValue(self, name, val)

    def setStringValue(self, name, val):
        r"""setStringValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_setStringValue(self, name, val)

    def getRealValue(self, name):
        r"""getRealValue(self, name) -> fmippReal"""
        return _fmippim.FMUCoSimulationV1_getRealValue(self, name)

    def getIntegerValue(self, name):
        r"""getIntegerValue(self, name) -> fmippInteger"""
        return _fmippim.FMUCoSimulationV1_getIntegerValue(self, name)

    def getBooleanValue(self, name):
        r"""getBooleanValue(self, name) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_getBooleanValue(self, name)

    def getStringValue(self, name):
        r"""getStringValue(self, name) -> fmippString"""
        return _fmippim.FMUCoSimulationV1_getStringValue(self, name)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_getLastStatus(self)

    def getValueRef(self, name):
        r"""getValueRef(self, name) -> fmippValueReference"""
        return _fmippim.FMUCoSimulationV1_getValueRef(self, name)

    def nStates(self):
        r"""nStates(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV1_nStates(self)

    def nEventInds(self):
        r"""nEventInds(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV1_nEventInds(self)

    def nValueRefs(self):
        r"""nValueRefs(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV1_nValueRefs(self)

    def getType(self, variableName):
        r"""getType(self, variableName) -> FMIPPVariableType"""
        return _fmippim.FMUCoSimulationV1_getType(self, variableName)

    def canHandleVariableCommunicationStepSize(self):
        r"""canHandleVariableCommunicationStepSize(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canHandleVariableCommunicationStepSize(self)

    def canHandleEvents(self):
        r"""canHandleEvents(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canHandleEvents(self)

    def canRejectSteps(self):
        r"""canRejectSteps(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canRejectSteps(self)

    def canInterpolateInputs(self):
        r"""canInterpolateInputs(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canInterpolateInputs(self)

    def maxOutputDerivativeOrder(self):
        r"""maxOutputDerivativeOrder(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV1_maxOutputDerivativeOrder(self)

    def canRunAsynchronuously(self):
        r"""canRunAsynchronuously(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canRunAsynchronuously(self)

    def canSignalEvents(self):
        r"""canSignalEvents(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canSignalEvents(self)

    def canBeInstantiatedOnlyOncePerProcess(self):
        r"""canBeInstantiatedOnlyOncePerProcess(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canBeInstantiatedOnlyOncePerProcess(self)

    def canNotUseMemoryManagementFunctions(self):
        r"""canNotUseMemoryManagementFunctions(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV1_canNotUseMemoryManagementFunctions(self)

    def sendDebugMessage(self, msg):
        r"""sendDebugMessage(self, msg)"""
        return _fmippim.FMUCoSimulationV1_sendDebugMessage(self, msg)

    def logger(self, *args):
        r"""
        logger(self, status, category, msg)
        logger(self, status, category, msg)
        """
        return _fmippim.FMUCoSimulationV1_logger(self, *args)

    def setCallbacks(self, logger, allocateMemory, freeMemory, stepFinished):
        r"""setCallbacks(self, logger, allocateMemory, freeMemory, stepFinished) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV1_setCallbacks(self, logger, allocateMemory, freeMemory, stepFinished)

# Register FMUCoSimulationV1 in _fmippim:
_fmippim.FMUCoSimulationV1_swigregister(FMUCoSimulationV1)

class FMUCoSimulationV2(object):
    r"""Proxy of C++ fmi_2_0::FMUCoSimulation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        FMUCoSimulation(fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-9) -> FMUCoSimulationV2
        FMUCoSimulation(modelIdentifier, loggingOn=False, timeDiffResolution=1e-9) -> FMUCoSimulationV2
        __init__(self, fmu) -> FMUCoSimulationV2
        """
        _fmippim.FMUCoSimulationV2_swiginit(self, _fmippim.new_FMUCoSimulationV2(*args))
    __swig_destroy__ = _fmippim.delete_FMUCoSimulationV2

    def terminate(self):
        r"""terminate(self)"""
        return _fmippim.FMUCoSimulationV2_terminate(self)

    def instantiate(self, instanceName, timeout, visible, interactive):
        r"""instantiate(self, instanceName, timeout, visible, interactive) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_instantiate(self, instanceName, timeout, visible, interactive)

    def initialize(self, startTime, stopTimeDefined, stopTime):
        r"""initialize(self, startTime, stopTimeDefined, stopTime) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_initialize(self, startTime, stopTimeDefined, stopTime)

    def doStep(self, currentCommunicationPoint, communicationStepSize, newStep):
        r"""doStep(self, currentCommunicationPoint, communicationStepSize, newStep) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_doStep(self, currentCommunicationPoint, communicationStepSize, newStep)

    def getTime(self):
        r"""getTime(self) -> fmippReal"""
        return _fmippim.FMUCoSimulationV2_getTime(self)

    def setRealValue(self, name, val):
        r"""setRealValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_setRealValue(self, name, val)

    def setIntegerValue(self, name, val):
        r"""setIntegerValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_setIntegerValue(self, name, val)

    def setBooleanValue(self, name, val):
        r"""setBooleanValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_setBooleanValue(self, name, val)

    def setStringValue(self, name, val):
        r"""setStringValue(self, name, val) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_setStringValue(self, name, val)

    def getRealValue(self, name):
        r"""getRealValue(self, name) -> fmippReal"""
        return _fmippim.FMUCoSimulationV2_getRealValue(self, name)

    def getIntegerValue(self, name):
        r"""getIntegerValue(self, name) -> fmippInteger"""
        return _fmippim.FMUCoSimulationV2_getIntegerValue(self, name)

    def getBooleanValue(self, name):
        r"""getBooleanValue(self, name) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_getBooleanValue(self, name)

    def getStringValue(self, name):
        r"""getStringValue(self, name) -> fmippString"""
        return _fmippim.FMUCoSimulationV2_getStringValue(self, name)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_getLastStatus(self)

    def getValueRef(self, name):
        r"""getValueRef(self, name) -> fmippValueReference"""
        return _fmippim.FMUCoSimulationV2_getValueRef(self, name)

    def nStates(self):
        r"""nStates(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV2_nStates(self)

    def nEventInds(self):
        r"""nEventInds(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV2_nEventInds(self)

    def nValueRefs(self):
        r"""nValueRefs(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV2_nValueRefs(self)

    def getType(self, variableName):
        r"""getType(self, variableName) -> FMIPPVariableType"""
        return _fmippim.FMUCoSimulationV2_getType(self, variableName)

    def canHandleVariableCommunicationStepSize(self):
        r"""canHandleVariableCommunicationStepSize(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canHandleVariableCommunicationStepSize(self)

    def canHandleEvents(self):
        r"""canHandleEvents(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canHandleEvents(self)

    def canRejectSteps(self):
        r"""canRejectSteps(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canRejectSteps(self)

    def canInterpolateInputs(self):
        r"""canInterpolateInputs(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canInterpolateInputs(self)

    def maxOutputDerivativeOrder(self):
        r"""maxOutputDerivativeOrder(self) -> fmippSize"""
        return _fmippim.FMUCoSimulationV2_maxOutputDerivativeOrder(self)

    def canRunAsynchronuously(self):
        r"""canRunAsynchronuously(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canRunAsynchronuously(self)

    def canSignalEvents(self):
        r"""canSignalEvents(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canSignalEvents(self)

    def canBeInstantiatedOnlyOncePerProcess(self):
        r"""canBeInstantiatedOnlyOncePerProcess(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canBeInstantiatedOnlyOncePerProcess(self)

    def canNotUseMemoryManagementFunctions(self):
        r"""canNotUseMemoryManagementFunctions(self) -> fmippBoolean"""
        return _fmippim.FMUCoSimulationV2_canNotUseMemoryManagementFunctions(self)

    def sendDebugMessage(self, msg):
        r"""sendDebugMessage(self, msg)"""
        return _fmippim.FMUCoSimulationV2_sendDebugMessage(self, msg)

    def logger(self, *args):
        r"""
        logger(self, status, category, msg)
        logger(self, status, category, msg)
        """
        return _fmippim.FMUCoSimulationV2_logger(self, *args)

    def setCallbacks(self, logger, allocateMemory, freeMemory, stepFinished):
        r"""setCallbacks(self, logger, allocateMemory, freeMemory, stepFinished) -> fmippStatus"""
        return _fmippim.FMUCoSimulationV2_setCallbacks(self, logger, allocateMemory, freeMemory, stepFinished)

    def setComponentEnvironment(self, env):
        r"""setComponentEnvironment(self, env)"""
        return _fmippim.FMUCoSimulationV2_setComponentEnvironment(self, env)

# Register FMUCoSimulationV2 in _fmippim:
_fmippim.FMUCoSimulationV2_swigregister(FMUCoSimulationV2)

class LogBuffer(object):
    r"""Proxy of C++ LogBuffer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fmippim.delete_LogBuffer

    @staticmethod
    def getLogBuffer():
        r"""getLogBuffer() -> LogBuffer"""
        return _fmippim.LogBuffer_getLogBuffer()

    def writeToBuffer(self, msg):
        r"""writeToBuffer(self, msg)"""
        return _fmippim.LogBuffer_writeToBuffer(self, msg)

    def readFromBuffer(self):
        r"""readFromBuffer(self) -> fmippString"""
        return _fmippim.LogBuffer_readFromBuffer(self)

    def clear(self):
        r"""clear(self)"""
        return _fmippim.LogBuffer_clear(self)

    def activate(self):
        r"""activate(self)"""
        return _fmippim.LogBuffer_activate(self)

    def deactivate(self):
        r"""deactivate(self)"""
        return _fmippim.LogBuffer_deactivate(self)

    def isActivated(self):
        r"""isActivated(self) -> bool"""
        return _fmippim.LogBuffer_isActivated(self)

# Register LogBuffer in _fmippim:
_fmippim.LogBuffer_swigregister(LogBuffer)

def LogBuffer_getLogBuffer():
    r"""LogBuffer_getLogBuffer() -> LogBuffer"""
    return _fmippim.LogBuffer_getLogBuffer()

integratorEU = _fmippim.integratorEU

integratorRK = _fmippim.integratorRK

integratorABM = _fmippim.integratorABM

integratorCK = _fmippim.integratorCK

integratorDP = _fmippim.integratorDP

integratorFE = _fmippim.integratorFE

integratorBS = _fmippim.integratorBS

integratorRO = _fmippim.integratorRO

integratorBDF = _fmippim.integratorBDF

integratorABM2 = _fmippim.integratorABM2

NSTEPPERS = _fmippim.NSTEPPERS

class IncrementalFMU(object):
    r"""Proxy of C++ IncrementalFMU class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4, integratorType=IntegratorType::bdf) -> IncrementalFMU
        __init__(self, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4, integratorType=IntegratorType::bdf) -> IncrementalFMU
        """
        _fmippim.IncrementalFMU_swiginit(self, _fmippim.new_IncrementalFMU(*args))
    __swig_destroy__ = _fmippim.delete_IncrementalFMU

    def init(self, *args):
        r"""
        init(self, instanceName, realVariableNames, realValues, nRealVars, startTime, lookAheadHorizon, lookAheadStepSize, integratorStepSize, toleranceDefined=False, tolerance=1e-5) -> int
        init(self, instanceName, realVariableNames, realValues, nRealVars, integerVariableNames, integerValues, nIntegerVars, booleanVariableNames, booleanValues, nBooleanVars, stringVariableNames, stringValues, nStringVars, startTime, lookAheadHorizon, lookAheadStepSize, integratorStepSize, toleranceDefined=False, tolerance=1e-5) -> int
        """
        return _fmippim.IncrementalFMU_init(self, *args)

    def setIntegratorProperties(self, prop):
        r"""setIntegratorProperties(self, prop)"""
        return _fmippim.IncrementalFMU_setIntegratorProperties(self, prop)

    def getIntegratorProperties(self):
        r"""getIntegratorProperties(self) -> Integrator::Properties"""
        return _fmippim.IncrementalFMU_getIntegratorProperties(self)

    def getType(self, varName):
        r"""getType(self, varName) -> FMIPPVariableType"""
        return _fmippim.IncrementalFMU_getType(self, varName)

    def defineRealInputs(self, inputs, nInputs):
        r"""defineRealInputs(self, inputs, nInputs)"""
        return _fmippim.IncrementalFMU_defineRealInputs(self, inputs, nInputs)

    def defineIntegerInputs(self, inputs, nInputs):
        r"""defineIntegerInputs(self, inputs, nInputs)"""
        return _fmippim.IncrementalFMU_defineIntegerInputs(self, inputs, nInputs)

    def defineBooleanInputs(self, inputs, nInputs):
        r"""defineBooleanInputs(self, inputs, nInputs)"""
        return _fmippim.IncrementalFMU_defineBooleanInputs(self, inputs, nInputs)

    def defineStringInputs(self, inputs, nInputs):
        r"""defineStringInputs(self, inputs, nInputs)"""
        return _fmippim.IncrementalFMU_defineStringInputs(self, inputs, nInputs)

    def defineRealOutputs(self, outputs, nOutputs):
        r"""defineRealOutputs(self, outputs, nOutputs)"""
        return _fmippim.IncrementalFMU_defineRealOutputs(self, outputs, nOutputs)

    def defineIntegerOutputs(self, outputs, nOutputs):
        r"""defineIntegerOutputs(self, outputs, nOutputs)"""
        return _fmippim.IncrementalFMU_defineIntegerOutputs(self, outputs, nOutputs)

    def defineBooleanOutputs(self, outputs, nOutputs):
        r"""defineBooleanOutputs(self, outputs, nOutputs)"""
        return _fmippim.IncrementalFMU_defineBooleanOutputs(self, outputs, nOutputs)

    def defineStringOutputs(self, outputs, nOutputs):
        r"""defineStringOutputs(self, outputs, nOutputs)"""
        return _fmippim.IncrementalFMU_defineStringOutputs(self, outputs, nOutputs)

    def getRealOutputs(self):
        r"""getRealOutputs(self) -> fmippReal *"""
        return _fmippim.IncrementalFMU_getRealOutputs(self)

    def getIntegerOutputs(self):
        r"""getIntegerOutputs(self) -> fmippInteger *"""
        return _fmippim.IncrementalFMU_getIntegerOutputs(self)

    def getBooleanOutputs(self):
        r"""getBooleanOutputs(self) -> fmippBoolean *"""
        return _fmippim.IncrementalFMU_getBooleanOutputs(self)

    def getStringOutputs(self):
        r"""getStringOutputs(self) -> fmippString *"""
        return _fmippim.IncrementalFMU_getStringOutputs(self)

    def sync(self, *args):
        r"""
        sync(self, t0, t1) -> fmippTime
        sync(self, t0, t1, realInputs, integerInputs=None, booleanInputs=None, stringInputs=None) -> fmippTime
        """
        return _fmippim.IncrementalFMU_sync(self, *args)

    def updateState(self, t1):
        r"""updateState(self, t1) -> fmippTime"""
        return _fmippim.IncrementalFMU_updateState(self, t1)

    def updateStateFromTheRight(self, t1):
        r"""updateStateFromTheRight(self, t1) -> fmippTime"""
        return _fmippim.IncrementalFMU_updateStateFromTheRight(self, t1)

    def syncState(self, t1, realInputs, integerInputs, booleanInputs, stringInputs):
        r"""syncState(self, t1, realInputs, integerInputs, booleanInputs, stringInputs)"""
        return _fmippim.IncrementalFMU_syncState(self, t1, realInputs, integerInputs, booleanInputs, stringInputs)

    def predictState(self, t1):
        r"""predictState(self, t1) -> fmippTime"""
        return _fmippim.IncrementalFMU_predictState(self, t1)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.IncrementalFMU_getLastStatus(self)

    def getTimeDiffResolution(self):
        r"""getTimeDiffResolution(self) -> fmippTime"""
        return _fmippim.IncrementalFMU_getTimeDiffResolution(self)

# Register IncrementalFMU in _fmippim:
_fmippim.IncrementalFMU_swigregister(IncrementalFMU)

class RollbackFMU(object):
    r"""Proxy of C++ RollbackFMU class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4, integratorType=IntegratorType::bdf) -> RollbackFMU"""
        _fmippim.RollbackFMU_swiginit(self, _fmippim.new_RollbackFMU(*args))
    __swig_destroy__ = _fmippim.delete_RollbackFMU

    def integrate(self, *args):
        r"""
        integrate(self, tstop, nsteps) -> fmippReal
        integrate(self, tstop, deltaT=1E-5) -> fmippReal
        """
        return _fmippim.RollbackFMU_integrate(self, *args)

    def saveCurrentStateForRollback(self):
        r"""saveCurrentStateForRollback(self)"""
        return _fmippim.RollbackFMU_saveCurrentStateForRollback(self)

    def releaseRollbackState(self):
        r"""releaseRollbackState(self)"""
        return _fmippim.RollbackFMU_releaseRollbackState(self)

    def getRealValue(self, name):
        r"""getRealValue(self, name) -> fmippReal"""
        return _fmippim.RollbackFMU_getRealValue(self, name)

    def getIntegerValue(self, name):
        r"""getIntegerValue(self, name) -> fmippInteger"""
        return _fmippim.RollbackFMU_getIntegerValue(self, name)

    def getBooleanValue(self, name):
        r"""getBooleanValue(self, name) -> fmippBoolean"""
        return _fmippim.RollbackFMU_getBooleanValue(self, name)

    def getStringValue(self, name):
        r"""getStringValue(self, name) -> fmippString"""
        return _fmippim.RollbackFMU_getStringValue(self, name)

    def getTime(self):
        r"""getTime(self) -> fmippTime"""
        return _fmippim.RollbackFMU_getTime(self)

    def initialize(self, toleranceDefined=False, tolerance=1e-5):
        r"""initialize(self, toleranceDefined=False, tolerance=1e-5) -> fmippStatus"""
        return _fmippim.RollbackFMU_initialize(self, toleranceDefined, tolerance)

    def instantiate(self, instanceName):
        r"""instantiate(self, instanceName) -> fmippStatus"""
        return _fmippim.RollbackFMU_instantiate(self, instanceName)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.RollbackFMU_getLastStatus(self)

# Register RollbackFMU in _fmippim:
_fmippim.RollbackFMU_swigregister(RollbackFMU)

class FixedStepSizeFMU(object):
    r"""Proxy of C++ FixedStepSizeFMU class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4):
        r"""__init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4) -> FixedStepSizeFMU"""
        _fmippim.FixedStepSizeFMU_swiginit(self, _fmippim.new_FixedStepSizeFMU(fmuDirUri, modelIdentifier, loggingOn, timeDiffResolution))
    __swig_destroy__ = _fmippim.delete_FixedStepSizeFMU

    def init(self, *args):
        r"""
        init(self, instanceName, realVariableNames, realValues, nRealVars, startTime, communicationStepSize, stopTimeDefined=False, stopTime=std::numeric_limits< fmippTime >::infinity(), timeout=0., visible=False, interactive=False) -> int
        init(self, instanceName, realVariableNames, realValues, nRealVars, integerVariableNames, integerValues, nIntegerVars, booleanVariableNames, booleanValues, nBooleanVars, stringVariableNames, stringValues, nStringVars, startTime, communicationStepSize, stopTimeDefined=False, stopTime=std::numeric_limits< fmippTime >::infinity(), timeout=0., visible=False, interactive=False) -> int
        """
        return _fmippim.FixedStepSizeFMU_init(self, *args)

    def defineRealInputs(self, inputs, nInputs):
        r"""defineRealInputs(self, inputs, nInputs)"""
        return _fmippim.FixedStepSizeFMU_defineRealInputs(self, inputs, nInputs)

    def defineIntegerInputs(self, inputs, nInputs):
        r"""defineIntegerInputs(self, inputs, nInputs)"""
        return _fmippim.FixedStepSizeFMU_defineIntegerInputs(self, inputs, nInputs)

    def defineBooleanInputs(self, inputs, nInputs):
        r"""defineBooleanInputs(self, inputs, nInputs)"""
        return _fmippim.FixedStepSizeFMU_defineBooleanInputs(self, inputs, nInputs)

    def defineStringInputs(self, inputs, nInputs):
        r"""defineStringInputs(self, inputs, nInputs)"""
        return _fmippim.FixedStepSizeFMU_defineStringInputs(self, inputs, nInputs)

    def defineRealOutputs(self, outputs, nOutputs):
        r"""defineRealOutputs(self, outputs, nOutputs)"""
        return _fmippim.FixedStepSizeFMU_defineRealOutputs(self, outputs, nOutputs)

    def defineIntegerOutputs(self, outputs, nOutputs):
        r"""defineIntegerOutputs(self, outputs, nOutputs)"""
        return _fmippim.FixedStepSizeFMU_defineIntegerOutputs(self, outputs, nOutputs)

    def defineBooleanOutputs(self, outputs, nOutputs):
        r"""defineBooleanOutputs(self, outputs, nOutputs)"""
        return _fmippim.FixedStepSizeFMU_defineBooleanOutputs(self, outputs, nOutputs)

    def defineStringOutputs(self, outputs, nOutputs):
        r"""defineStringOutputs(self, outputs, nOutputs)"""
        return _fmippim.FixedStepSizeFMU_defineStringOutputs(self, outputs, nOutputs)

    def getRealOutputs(self):
        r"""getRealOutputs(self) -> fmippReal *"""
        return _fmippim.FixedStepSizeFMU_getRealOutputs(self)

    def getIntegerOutputs(self):
        r"""getIntegerOutputs(self) -> fmippInteger *"""
        return _fmippim.FixedStepSizeFMU_getIntegerOutputs(self)

    def getBooleanOutputs(self):
        r"""getBooleanOutputs(self) -> fmippBoolean *"""
        return _fmippim.FixedStepSizeFMU_getBooleanOutputs(self)

    def getStringOutputs(self):
        r"""getStringOutputs(self) -> fmippString *"""
        return _fmippim.FixedStepSizeFMU_getStringOutputs(self)

    def sync(self, *args):
        r"""
        sync(self, t0, t1) -> fmippTime
        sync(self, t0, t1, realInputs, integerInputs, booleanInputs, stringInputs, iterateOnce=False) -> fmippTime
        """
        return _fmippim.FixedStepSizeFMU_sync(self, *args)

    def iterateOnce(self):
        r"""iterateOnce(self)"""
        return _fmippim.FixedStepSizeFMU_iterateOnce(self)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.FixedStepSizeFMU_getLastStatus(self)

# Register FixedStepSizeFMU in _fmippim:
_fmippim.FixedStepSizeFMU_swigregister(FixedStepSizeFMU)

class VariableStepSizeFMU(object):
    r"""Proxy of C++ VariableStepSizeFMU class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4):
        r"""__init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4) -> VariableStepSizeFMU"""
        _fmippim.VariableStepSizeFMU_swiginit(self, _fmippim.new_VariableStepSizeFMU(fmuDirUri, modelIdentifier, loggingOn, timeDiffResolution))
    __swig_destroy__ = _fmippim.delete_VariableStepSizeFMU

    def init(self, *args):
        r"""
        init(self, instanceName, realVariableNames, realValues, nRealVars, startTime, defaultCommunicationStepSize, stopTimeDefined=False, stopTime=std::numeric_limits< fmippTime >::infinity(), timeout=0., visible=False, interactive=False) -> int
        init(self, instanceName, realVariableNames, realValues, nRealVars, integerVariableNames, integerValues, nIntegerVars, booleanVariableNames, booleanValues, nBooleanVars, stringVariableNames, stringValues, nStringVars, startTime, communicationStepSize, stopTimeDefined=False, stopTime=std::numeric_limits< fmippTime >::infinity(), timeout=0., visible=False, interactive=False) -> int
        """
        return _fmippim.VariableStepSizeFMU_init(self, *args)

    def defineRealInputs(self, inputs, nInputs):
        r"""defineRealInputs(self, inputs, nInputs)"""
        return _fmippim.VariableStepSizeFMU_defineRealInputs(self, inputs, nInputs)

    def defineIntegerInputs(self, inputs, nInputs):
        r"""defineIntegerInputs(self, inputs, nInputs)"""
        return _fmippim.VariableStepSizeFMU_defineIntegerInputs(self, inputs, nInputs)

    def defineBooleanInputs(self, inputs, nInputs):
        r"""defineBooleanInputs(self, inputs, nInputs)"""
        return _fmippim.VariableStepSizeFMU_defineBooleanInputs(self, inputs, nInputs)

    def defineStringInputs(self, inputs, nInputs):
        r"""defineStringInputs(self, inputs, nInputs)"""
        return _fmippim.VariableStepSizeFMU_defineStringInputs(self, inputs, nInputs)

    def defineRealOutputs(self, outputs, nOutputs):
        r"""defineRealOutputs(self, outputs, nOutputs)"""
        return _fmippim.VariableStepSizeFMU_defineRealOutputs(self, outputs, nOutputs)

    def defineIntegerOutputs(self, outputs, nOutputs):
        r"""defineIntegerOutputs(self, outputs, nOutputs)"""
        return _fmippim.VariableStepSizeFMU_defineIntegerOutputs(self, outputs, nOutputs)

    def defineBooleanOutputs(self, outputs, nOutputs):
        r"""defineBooleanOutputs(self, outputs, nOutputs)"""
        return _fmippim.VariableStepSizeFMU_defineBooleanOutputs(self, outputs, nOutputs)

    def defineStringOutputs(self, outputs, nOutputs):
        r"""defineStringOutputs(self, outputs, nOutputs)"""
        return _fmippim.VariableStepSizeFMU_defineStringOutputs(self, outputs, nOutputs)

    def getRealOutputs(self):
        r"""getRealOutputs(self) -> fmippReal *"""
        return _fmippim.VariableStepSizeFMU_getRealOutputs(self)

    def getIntegerOutputs(self):
        r"""getIntegerOutputs(self) -> fmippInteger *"""
        return _fmippim.VariableStepSizeFMU_getIntegerOutputs(self)

    def getBooleanOutputs(self):
        r"""getBooleanOutputs(self) -> fmippBoolean *"""
        return _fmippim.VariableStepSizeFMU_getBooleanOutputs(self)

    def getStringOutputs(self):
        r"""getStringOutputs(self) -> fmippString *"""
        return _fmippim.VariableStepSizeFMU_getStringOutputs(self)

    def sync(self, *args):
        r"""
        sync(self, t0, t1) -> fmippTime
        sync(self, t0, t1, realInputs, integerInputs, booleanInputs, stringInputs, iterateOnce=False) -> fmippTime
        """
        return _fmippim.VariableStepSizeFMU_sync(self, *args)

    def iterateOnce(self):
        r"""iterateOnce(self)"""
        return _fmippim.VariableStepSizeFMU_iterateOnce(self)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.VariableStepSizeFMU_getLastStatus(self)

# Register VariableStepSizeFMU in _fmippim:
_fmippim.VariableStepSizeFMU_swigregister(VariableStepSizeFMU)

class InterpolatingFixedStepSizeFMU(object):
    r"""Proxy of C++ InterpolatingFixedStepSizeFMU class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4):
        r"""__init__(self, fmuDirUri, modelIdentifier, loggingOn=False, timeDiffResolution=1e-4) -> InterpolatingFixedStepSizeFMU"""
        _fmippim.InterpolatingFixedStepSizeFMU_swiginit(self, _fmippim.new_InterpolatingFixedStepSizeFMU(fmuDirUri, modelIdentifier, loggingOn, timeDiffResolution))
    __swig_destroy__ = _fmippim.delete_InterpolatingFixedStepSizeFMU

    def init(self, *args):
        r"""
        init(self, instanceName, realVariableNames, realValues, nRealVars, startTime, communicationStepSize, stopTimeDefined=False, stopTime=std::numeric_limits< fmippTime >::infinity(), timeout=0., visible=False, interactive=False) -> int
        init(self, instanceName, realVariableNames, realValues, nRealVars, integerVariableNames, integerValues, nIntegerVars, booleanVariableNames, booleanValues, nBooleanVars, stringVariableNames, stringValues, nStringVars, startTime, communicationStepSize, stopTimeDefined=False, stopTime=std::numeric_limits< fmippTime >::infinity(), timeout=0., visible=False, interactive=False) -> int
        """
        return _fmippim.InterpolatingFixedStepSizeFMU_init(self, *args)

    def defineRealInputs(self, inputs, nInputs):
        r"""defineRealInputs(self, inputs, nInputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineRealInputs(self, inputs, nInputs)

    def defineIntegerInputs(self, inputs, nInputs):
        r"""defineIntegerInputs(self, inputs, nInputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineIntegerInputs(self, inputs, nInputs)

    def defineBooleanInputs(self, inputs, nInputs):
        r"""defineBooleanInputs(self, inputs, nInputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineBooleanInputs(self, inputs, nInputs)

    def defineStringInputs(self, inputs, nInputs):
        r"""defineStringInputs(self, inputs, nInputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineStringInputs(self, inputs, nInputs)

    def defineRealOutputs(self, outputs, nOutputs):
        r"""defineRealOutputs(self, outputs, nOutputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineRealOutputs(self, outputs, nOutputs)

    def defineIntegerOutputs(self, outputs, nOutputs):
        r"""defineIntegerOutputs(self, outputs, nOutputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineIntegerOutputs(self, outputs, nOutputs)

    def defineBooleanOutputs(self, outputs, nOutputs):
        r"""defineBooleanOutputs(self, outputs, nOutputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineBooleanOutputs(self, outputs, nOutputs)

    def defineStringOutputs(self, outputs, nOutputs):
        r"""defineStringOutputs(self, outputs, nOutputs)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_defineStringOutputs(self, outputs, nOutputs)

    def getRealOutputs(self):
        r"""getRealOutputs(self) -> fmippReal *"""
        return _fmippim.InterpolatingFixedStepSizeFMU_getRealOutputs(self)

    def getIntegerOutputs(self):
        r"""getIntegerOutputs(self) -> fmippInteger *"""
        return _fmippim.InterpolatingFixedStepSizeFMU_getIntegerOutputs(self)

    def getBooleanOutputs(self):
        r"""getBooleanOutputs(self) -> fmippBoolean *"""
        return _fmippim.InterpolatingFixedStepSizeFMU_getBooleanOutputs(self)

    def getStringOutputs(self):
        r"""getStringOutputs(self) -> fmippString *"""
        return _fmippim.InterpolatingFixedStepSizeFMU_getStringOutputs(self)

    def sync(self, *args):
        r"""
        sync(self, t0, t1) -> fmippTime
        sync(self, t0, t1, realInputs, integerInputs, booleanInputs, stringInputs, iterateOnce=False) -> fmippTime
        """
        return _fmippim.InterpolatingFixedStepSizeFMU_sync(self, *args)

    def iterateOnce(self):
        r"""iterateOnce(self)"""
        return _fmippim.InterpolatingFixedStepSizeFMU_iterateOnce(self)

    def getLastStatus(self):
        r"""getLastStatus(self) -> fmippStatus"""
        return _fmippim.InterpolatingFixedStepSizeFMU_getLastStatus(self)

# Register InterpolatingFixedStepSizeFMU in _fmippim:
_fmippim.InterpolatingFixedStepSizeFMU_swigregister(InterpolatingFixedStepSizeFMU)



