# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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

# Import the low-level C/C++ module
import sys
import importlib

low_level_module_name = '_Nanolib' + '_%d_%d' % (sys.version_info.major, sys.version_info.minor)

try:
    if __package__ or '.' in __name__:
        _Nanolib = importlib.import_module('.' + low_level_module_name, __package__)
    else:
        _Nanolib = importlib.import_module(low_level_module_name)
except ImportError:
    if __package__ or '.' in __name__:
        from . import _Nanolib
    else:
        import _Nanolib


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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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__)


import weakref

class imaxdiv_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    quot = property(_Nanolib.imaxdiv_t_quot_get, _Nanolib.imaxdiv_t_quot_set)
    rem = property(_Nanolib.imaxdiv_t_rem_get, _Nanolib.imaxdiv_t_rem_set)

    def __init__(self):
        _Nanolib.imaxdiv_t_swiginit(self, _Nanolib.new_imaxdiv_t())
    __swig_destroy__ = _Nanolib.delete_imaxdiv_t

# Register imaxdiv_t in _Nanolib:
_Nanolib.imaxdiv_t_swigregister(imaxdiv_t)

def wcstoimax(nptr, endptr, base):
    return _Nanolib.wcstoimax(nptr, endptr, base)

def wcstoumax(nptr, endptr, base):
    return _Nanolib.wcstoumax(nptr, endptr, base)
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__ = _Nanolib.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _Nanolib:
_Nanolib.SwigPyIterator_swigregister(SwigPyIterator)
class OdIndex(object):
    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):
        _Nanolib.OdIndex_swiginit(self, _Nanolib.new_OdIndex(*args))

    def getIndex(self):
        return _Nanolib.OdIndex_getIndex(self)

    def getSubIndex(self):
        return _Nanolib.OdIndex_getSubIndex(self)

    def toString(self):
        return _Nanolib.OdIndex_toString(self)
    __swig_destroy__ = _Nanolib.delete_OdIndex

# Register OdIndex in _Nanolib:
_Nanolib.OdIndex_swigregister(OdIndex)
NlcErrorCode_Success = _Nanolib.NlcErrorCode_Success
NlcErrorCode_GeneralError = _Nanolib.NlcErrorCode_GeneralError
NlcErrorCode_BusUnavailable = _Nanolib.NlcErrorCode_BusUnavailable
NlcErrorCode_CommunicationError = _Nanolib.NlcErrorCode_CommunicationError
NlcErrorCode_ProtocolError = _Nanolib.NlcErrorCode_ProtocolError
NlcErrorCode_ODDoesNotExist = _Nanolib.NlcErrorCode_ODDoesNotExist
NlcErrorCode_ODInvalidAccess = _Nanolib.NlcErrorCode_ODInvalidAccess
NlcErrorCode_ODTypeMismatch = _Nanolib.NlcErrorCode_ODTypeMismatch
NlcErrorCode_OperationAborted = _Nanolib.NlcErrorCode_OperationAborted
NlcErrorCode_OperationNotSupported = _Nanolib.NlcErrorCode_OperationNotSupported
NlcErrorCode_InvalidOperation = _Nanolib.NlcErrorCode_InvalidOperation
NlcErrorCode_InvalidArguments = _Nanolib.NlcErrorCode_InvalidArguments
NlcErrorCode_AccessDenied = _Nanolib.NlcErrorCode_AccessDenied
NlcErrorCode_ResourceNotFound = _Nanolib.NlcErrorCode_ResourceNotFound
NlcErrorCode_ResourceUnavailable = _Nanolib.NlcErrorCode_ResourceUnavailable
NlcErrorCode_OutOfMemory = _Nanolib.NlcErrorCode_OutOfMemory
NlcErrorCode_TimeoutError = _Nanolib.NlcErrorCode_TimeoutError
class BusHardwareId(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Nanolib.delete_BusHardwareId

    def __init__(self, *args):
        _Nanolib.BusHardwareId_swiginit(self, _Nanolib.new_BusHardwareId(*args))

    def getBusHardware(self):
        return _Nanolib.BusHardwareId_getBusHardware(self)

    def getProtocol(self):
        return _Nanolib.BusHardwareId_getProtocol(self)

    def getHardwareSpecifier(self):
        return _Nanolib.BusHardwareId_getHardwareSpecifier(self)

    def getExtraHardwareSpecifier(self):
        return _Nanolib.BusHardwareId_getExtraHardwareSpecifier(self)

    def getName(self):
        return _Nanolib.BusHardwareId_getName(self)

    def equals(self, other):
        return _Nanolib.BusHardwareId_equals(self, other)

    def toString(self):
        return _Nanolib.BusHardwareId_toString(self)

# Register BusHardwareId in _Nanolib:
_Nanolib.BusHardwareId_swigregister(BusHardwareId)
class BusHardwareOptions(object):
    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):
        _Nanolib.BusHardwareOptions_swiginit(self, _Nanolib.new_BusHardwareOptions(*args))

    def addOption(self, key, value):
        return _Nanolib.BusHardwareOptions_addOption(self, key, value)

    def getOptions(self):
        return _Nanolib.BusHardwareOptions_getOptions(self)

    def equals(self, other):
        return _Nanolib.BusHardwareOptions_equals(self, other)

    def toString(self):
        return _Nanolib.BusHardwareOptions_toString(self)
    __swig_destroy__ = _Nanolib.delete_BusHardwareOptions

# Register BusHardwareOptions in _Nanolib:
_Nanolib.BusHardwareOptions_swigregister(BusHardwareOptions)
class DeviceId(object):
    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):
        _Nanolib.DeviceId_swiginit(self, _Nanolib.new_DeviceId(*args))

    def getBusHardwareId(self):
        return _Nanolib.DeviceId_getBusHardwareId(self)

    def getDeviceId(self):
        return _Nanolib.DeviceId_getDeviceId(self)

    def getDescription(self):
        return _Nanolib.DeviceId_getDescription(self)

    def getExtraId(self):
        return _Nanolib.DeviceId_getExtraId(self)

    def getExtraStringId(self):
        return _Nanolib.DeviceId_getExtraStringId(self)

    def toString(self):
        return _Nanolib.DeviceId_toString(self)

    def equals(self, other):
        return _Nanolib.DeviceId_equals(self, other)
    __swig_destroy__ = _Nanolib.delete_DeviceId

# Register DeviceId in _Nanolib:
_Nanolib.DeviceId_swigregister(DeviceId)
class DeviceHandle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Nanolib.DeviceHandle_swiginit(self, _Nanolib.new_DeviceHandle())

    def equals(self, other):
        return _Nanolib.DeviceHandle_equals(self, other)

    def toString(self):
        return _Nanolib.DeviceHandle_toString(self)
    __swig_destroy__ = _Nanolib.delete_DeviceHandle

# Register DeviceHandle in _Nanolib:
_Nanolib.DeviceHandle_swigregister(DeviceHandle)
ObjectCode_Null = _Nanolib.ObjectCode_Null
ObjectCode_Deftype = _Nanolib.ObjectCode_Deftype
ObjectCode_Defstruct = _Nanolib.ObjectCode_Defstruct
ObjectCode_Var = _Nanolib.ObjectCode_Var
ObjectCode_Array = _Nanolib.ObjectCode_Array
ObjectCode_Record = _Nanolib.ObjectCode_Record
ObjectModificationAttribute_Constant = _Nanolib.ObjectModificationAttribute_Constant
ObjectModificationAttribute_Variable = _Nanolib.ObjectModificationAttribute_Variable
ObjectSdoAccessAttribute_ReadOnly = _Nanolib.ObjectSdoAccessAttribute_ReadOnly
ObjectSdoAccessAttribute_WriteOnly = _Nanolib.ObjectSdoAccessAttribute_WriteOnly
ObjectSdoAccessAttribute_ReadWrite = _Nanolib.ObjectSdoAccessAttribute_ReadWrite
ObjectSdoAccessAttribute_NoAccess = _Nanolib.ObjectSdoAccessAttribute_NoAccess
ObjectPdoAccessAttribute_Tx = _Nanolib.ObjectPdoAccessAttribute_Tx
ObjectPdoAccessAttribute_Rx = _Nanolib.ObjectPdoAccessAttribute_Rx
ObjectPdoAccessAttribute_TxRx = _Nanolib.ObjectPdoAccessAttribute_TxRx
ObjectPdoAccessAttribute_No = _Nanolib.ObjectPdoAccessAttribute_No
ObjectEntryDataType_Invalid = _Nanolib.ObjectEntryDataType_Invalid
ObjectEntryDataType_Boolean = _Nanolib.ObjectEntryDataType_Boolean
ObjectEntryDataType_Integer8 = _Nanolib.ObjectEntryDataType_Integer8
ObjectEntryDataType_Integer16 = _Nanolib.ObjectEntryDataType_Integer16
ObjectEntryDataType_Integer32 = _Nanolib.ObjectEntryDataType_Integer32
ObjectEntryDataType_Unsigned8 = _Nanolib.ObjectEntryDataType_Unsigned8
ObjectEntryDataType_Unsigned16 = _Nanolib.ObjectEntryDataType_Unsigned16
ObjectEntryDataType_Unsigned32 = _Nanolib.ObjectEntryDataType_Unsigned32
ObjectEntryDataType_Real32 = _Nanolib.ObjectEntryDataType_Real32
ObjectEntryDataType_VisibleString = _Nanolib.ObjectEntryDataType_VisibleString
ObjectEntryDataType_OctetString = _Nanolib.ObjectEntryDataType_OctetString
ObjectEntryDataType_UnicodeString = _Nanolib.ObjectEntryDataType_UnicodeString
ObjectEntryDataType_TimeOfDay = _Nanolib.ObjectEntryDataType_TimeOfDay
ObjectEntryDataType_TimeDifference = _Nanolib.ObjectEntryDataType_TimeDifference
ObjectEntryDataType_Domain = _Nanolib.ObjectEntryDataType_Domain
ObjectEntryDataType_Integer24 = _Nanolib.ObjectEntryDataType_Integer24
ObjectEntryDataType_Real64 = _Nanolib.ObjectEntryDataType_Real64
ObjectEntryDataType_Integer40 = _Nanolib.ObjectEntryDataType_Integer40
ObjectEntryDataType_Integer48 = _Nanolib.ObjectEntryDataType_Integer48
ObjectEntryDataType_Integer56 = _Nanolib.ObjectEntryDataType_Integer56
ObjectEntryDataType_Integer64 = _Nanolib.ObjectEntryDataType_Integer64
ObjectEntryDataType_Unsigned24 = _Nanolib.ObjectEntryDataType_Unsigned24
ObjectEntryDataType_Unsigned40 = _Nanolib.ObjectEntryDataType_Unsigned40
ObjectEntryDataType_Unsigned48 = _Nanolib.ObjectEntryDataType_Unsigned48
ObjectEntryDataType_Unsigned56 = _Nanolib.ObjectEntryDataType_Unsigned56
ObjectEntryDataType_Unsigned64 = _Nanolib.ObjectEntryDataType_Unsigned64
ObjectEntryDataType_PdoCommunicationParameter = _Nanolib.ObjectEntryDataType_PdoCommunicationParameter
ObjectEntryDataType_PdoMapping = _Nanolib.ObjectEntryDataType_PdoMapping
ObjectEntryDataType_Identity = _Nanolib.ObjectEntryDataType_Identity
ObjectEntryDataType_SyncmgrSynchronization = _Nanolib.ObjectEntryDataType_SyncmgrSynchronization
ObjectEntryDataType_UserStorageArea = _Nanolib.ObjectEntryDataType_UserStorageArea
ObjectEntryDataType_SamplerConfig = _Nanolib.ObjectEntryDataType_SamplerConfig
ObjectEntryDataType_SamplerTimebase = _Nanolib.ObjectEntryDataType_SamplerTimebase
ObjectEntryDataType_PdiInput = _Nanolib.ObjectEntryDataType_PdiInput
ObjectEntryDataType_PdiOutput = _Nanolib.ObjectEntryDataType_PdiOutput
ObjectEntryDataType_ClosedLoopControllerParameter = _Nanolib.ObjectEntryDataType_ClosedLoopControllerParameter
ObjectEntryDataType_OpenLoopControllerParameter = _Nanolib.ObjectEntryDataType_OpenLoopControllerParameter
ObjectEntryDataType_SsiEncoder = _Nanolib.ObjectEntryDataType_SsiEncoder
ObjectEntryDataType_N2 = _Nanolib.ObjectEntryDataType_N2
ObjectEntryDataType_N4 = _Nanolib.ObjectEntryDataType_N4
ObjectEntryDataType_V2 = _Nanolib.ObjectEntryDataType_V2
ObjectEntryDataType_X2 = _Nanolib.ObjectEntryDataType_X2
ObjectEntryDataType_X4 = _Nanolib.ObjectEntryDataType_X4
ObjectEntryDataType_InterpolationTimePeriod = _Nanolib.ObjectEntryDataType_InterpolationTimePeriod
ObjectEntryDataType_InterpolationDataConfiguration = _Nanolib.ObjectEntryDataType_InterpolationDataConfiguration
ObjectEntryDataType_VelocityAccelerationDeceleration = _Nanolib.ObjectEntryDataType_VelocityAccelerationDeceleration
ObjectEntryDataType_Simple = _Nanolib.ObjectEntryDataType_Simple
ObjectEntryDataType_Complex = _Nanolib.ObjectEntryDataType_Complex
ObjectEntryDataType_Unknown = _Nanolib.ObjectEntryDataType_Unknown
ObjectSaveable_APPLICATION = _Nanolib.ObjectSaveable_APPLICATION
ObjectSaveable_COMMUNICATION = _Nanolib.ObjectSaveable_COMMUNICATION
ObjectSaveable_DRIVE = _Nanolib.ObjectSaveable_DRIVE
ObjectSaveable_MISC_CONFIG = _Nanolib.ObjectSaveable_MISC_CONFIG
ObjectSaveable_MODBUS_RTU = _Nanolib.ObjectSaveable_MODBUS_RTU
ObjectSaveable_NO = _Nanolib.ObjectSaveable_NO
ObjectSaveable_TUNING = _Nanolib.ObjectSaveable_TUNING
ObjectSaveable_CUSTOMER = _Nanolib.ObjectSaveable_CUSTOMER
ObjectSaveable_ETHERNET = _Nanolib.ObjectSaveable_ETHERNET
ObjectSaveable_CANOPEN = _Nanolib.ObjectSaveable_CANOPEN
ObjectSaveable_PROFIBUS = _Nanolib.ObjectSaveable_PROFIBUS
ObjectSaveable_VERIFY1020 = _Nanolib.ObjectSaveable_VERIFY1020
ObjectSaveable_UNKNOWN_SAVEABLE_TYPE = _Nanolib.ObjectSaveable_UNKNOWN_SAVEABLE_TYPE
class OdTypesHelper(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")
    __repr__ = _swig_repr

    @staticmethod
    def uintToObjectCode(objectCode):
        return _Nanolib.OdTypesHelper_uintToObjectCode(objectCode)

    @staticmethod
    def isNumericDataType(dataType):
        return _Nanolib.OdTypesHelper_isNumericDataType(dataType)

    @staticmethod
    def isDefstructIndex(typeNum):
        return _Nanolib.OdTypesHelper_isDefstructIndex(typeNum)

    @staticmethod
    def isDeftypeIndex(typeNum):
        return _Nanolib.OdTypesHelper_isDeftypeIndex(typeNum)

    @staticmethod
    def isComplexDataType(dataType):
        return _Nanolib.OdTypesHelper_isComplexDataType(dataType)

    @staticmethod
    def uintToObjectEntryDataType(objectDataType):
        return _Nanolib.OdTypesHelper_uintToObjectEntryDataType(objectDataType)

    @staticmethod
    def objectEntryDataTypeToString(odDataType):
        return _Nanolib.OdTypesHelper_objectEntryDataTypeToString(odDataType)

    @staticmethod
    def stringToObjectEntryDatatype(dataTypeString):
        return _Nanolib.OdTypesHelper_stringToObjectEntryDatatype(dataTypeString)

    @staticmethod
    def objectEntryDataTypeBitLength(dataType):
        return _Nanolib.OdTypesHelper_objectEntryDataTypeBitLength(dataType)

# Register OdTypesHelper in _Nanolib:
_Nanolib.OdTypesHelper_swigregister(OdTypesHelper)
DataTransferInfo_FileOpen = _Nanolib.DataTransferInfo_FileOpen
DataTransferInfo_Init = _Nanolib.DataTransferInfo_Init
DataTransferInfo_Progress = _Nanolib.DataTransferInfo_Progress
DataTransferInfo_Reboot = _Nanolib.DataTransferInfo_Reboot
DataTransferInfo_Finished = _Nanolib.DataTransferInfo_Finished
BusScanInfo_Start = _Nanolib.BusScanInfo_Start
BusScanInfo_Progress = _Nanolib.BusScanInfo_Progress
BusScanInfo_FoundDevice = _Nanolib.BusScanInfo_FoundDevice
BusScanInfo_Finished = _Nanolib.BusScanInfo_Finished
DeviceConnectionStateInfo_Disconnected = _Nanolib.DeviceConnectionStateInfo_Disconnected
DeviceConnectionStateInfo_Connected = _Nanolib.DeviceConnectionStateInfo_Connected
DeviceConnectionStateInfo_ConnectedBootloader = _Nanolib.DeviceConnectionStateInfo_ConnectedBootloader
class CanOpenNmtState(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    STOPPED = property(_Nanolib.CanOpenNmtState_STOPPED_get)
    PRE_OPERATIONAL = property(_Nanolib.CanOpenNmtState_PRE_OPERATIONAL_get)
    OPERATIONAL = property(_Nanolib.CanOpenNmtState_OPERATIONAL_get)
    INITIALIZATION = property(_Nanolib.CanOpenNmtState_INITIALIZATION_get)
    UNKNOWN = property(_Nanolib.CanOpenNmtState_UNKNOWN_get)

    def __init__(self):
        _Nanolib.CanOpenNmtState_swiginit(self, _Nanolib.new_CanOpenNmtState())
    __swig_destroy__ = _Nanolib.delete_CanOpenNmtState

# Register CanOpenNmtState in _Nanolib:
_Nanolib.CanOpenNmtState_swigregister(CanOpenNmtState)
cvar = _Nanolib.cvar
NANOTEC_VENDOR_ID = cvar.NANOTEC_VENDOR_ID

class CanOpenNmtService(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    START = property(_Nanolib.CanOpenNmtService_START_get)
    STOP = property(_Nanolib.CanOpenNmtService_STOP_get)
    PRE_OPERATIONAL = property(_Nanolib.CanOpenNmtService_PRE_OPERATIONAL_get)
    RESET = property(_Nanolib.CanOpenNmtService_RESET_get)
    RESET_COMMUNICATION = property(_Nanolib.CanOpenNmtService_RESET_COMMUNICATION_get)

    def __init__(self):
        _Nanolib.CanOpenNmtService_swiginit(self, _Nanolib.new_CanOpenNmtService())
    __swig_destroy__ = _Nanolib.delete_CanOpenNmtService

# Register CanOpenNmtService in _Nanolib:
_Nanolib.CanOpenNmtService_swigregister(CanOpenNmtService)
class EtherCATState(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NONE = property(_Nanolib.EtherCATState_NONE_get)
    INIT = property(_Nanolib.EtherCATState_INIT_get)
    PRE_OPERATIONAL = property(_Nanolib.EtherCATState_PRE_OPERATIONAL_get)
    BOOT = property(_Nanolib.EtherCATState_BOOT_get)
    SAFE_OPERATIONAL = property(_Nanolib.EtherCATState_SAFE_OPERATIONAL_get)
    OPERATIONAL = property(_Nanolib.EtherCATState_OPERATIONAL_get)

    def __init__(self):
        _Nanolib.EtherCATState_swiginit(self, _Nanolib.new_EtherCATState())
    __swig_destroy__ = _Nanolib.delete_EtherCATState

# Register EtherCATState in _Nanolib:
_Nanolib.EtherCATState_swigregister(EtherCATState)
LOG_LEVEL_TRACE = _Nanolib.LOG_LEVEL_TRACE
LOG_LEVEL_DEBUG = _Nanolib.LOG_LEVEL_DEBUG
LOG_LEVEL_INFO = _Nanolib.LOG_LEVEL_INFO
LOG_LEVEL_WARN = _Nanolib.LOG_LEVEL_WARN
LOG_LEVEL_ERROR = _Nanolib.LOG_LEVEL_ERROR
LOG_LEVEL_CRITICAL = _Nanolib.LOG_LEVEL_CRITICAL
LOG_LEVEL_OFF = _Nanolib.LOG_LEVEL_OFF
LogLevel_Trace = _Nanolib.LogLevel_Trace
LogLevel_Debug = _Nanolib.LogLevel_Debug
LogLevel_Info = _Nanolib.LogLevel_Info
LogLevel_Warning = _Nanolib.LogLevel_Warning
LogLevel_Error = _Nanolib.LogLevel_Error
LogLevel_Critical = _Nanolib.LogLevel_Critical
LogLevel_Off = _Nanolib.LogLevel_Off
LogLevel_n_levels = _Nanolib.LogLevel_n_levels
class LogLevelConverter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def toString(logLevel):
        return _Nanolib.LogLevelConverter_toString(logLevel)

    def __init__(self):
        _Nanolib.LogLevelConverter_swiginit(self, _Nanolib.new_LogLevelConverter())
    __swig_destroy__ = _Nanolib.delete_LogLevelConverter

# Register LogLevelConverter in _Nanolib:
_Nanolib.LogLevelConverter_swigregister(LogLevelConverter)
canOpenNmtState = cvar.canOpenNmtState
canOpenNmtService = cvar.canOpenNmtService
EtherCATStates = cvar.EtherCATStates

class Result(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__ = _Nanolib.delete_Result

    def hasError(self):
        return _Nanolib.Result_hasError(self)

    def getError(self):
        return _Nanolib.Result_getError(self)

    def getErrorCode(self):
        return _Nanolib.Result_getErrorCode(self)

    def getExErrorCode(self):
        return _Nanolib.Result_getExErrorCode(self)

# Register Result in _Nanolib:
_Nanolib.Result_swigregister(Result)
class ResultVoid(Result):
    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):
        _Nanolib.ResultVoid_swiginit(self, _Nanolib.new_ResultVoid(*args))
    __swig_destroy__ = _Nanolib.delete_ResultVoid

# Register ResultVoid in _Nanolib:
_Nanolib.ResultVoid_swigregister(ResultVoid)
class ResultInt(Result):
    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):
        _Nanolib.ResultInt_swiginit(self, _Nanolib.new_ResultInt(*args))
    __swig_destroy__ = _Nanolib.delete_ResultInt

    def getResult(self):
        return _Nanolib.ResultInt_getResult(self)

# Register ResultInt in _Nanolib:
_Nanolib.ResultInt_swigregister(ResultInt)
class ResultString(Result):
    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):
        _Nanolib.ResultString_swiginit(self, _Nanolib.new_ResultString(*args))
    __swig_destroy__ = _Nanolib.delete_ResultString

    def getResult(self):
        return _Nanolib.ResultString_getResult(self)

# Register ResultString in _Nanolib:
_Nanolib.ResultString_swigregister(ResultString)
class ResultArrayInt(Result):
    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):
        _Nanolib.ResultArrayInt_swiginit(self, _Nanolib.new_ResultArrayInt(*args))
    __swig_destroy__ = _Nanolib.delete_ResultArrayInt

    def getResult(self):
        return _Nanolib.ResultArrayInt_getResult(self)

# Register ResultArrayInt in _Nanolib:
_Nanolib.ResultArrayInt_swigregister(ResultArrayInt)
class ResultArrayByte(Result):
    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):
        _Nanolib.ResultArrayByte_swiginit(self, _Nanolib.new_ResultArrayByte(*args))
    __swig_destroy__ = _Nanolib.delete_ResultArrayByte

    def getResult(self):
        return _Nanolib.ResultArrayByte_getResult(self)

# Register ResultArrayByte in _Nanolib:
_Nanolib.ResultArrayByte_swigregister(ResultArrayByte)
class ResultBusHwIds(Result):
    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):
        _Nanolib.ResultBusHwIds_swiginit(self, _Nanolib.new_ResultBusHwIds(*args))
    __swig_destroy__ = _Nanolib.delete_ResultBusHwIds

    def getResult(self):
        return _Nanolib.ResultBusHwIds_getResult(self)

# Register ResultBusHwIds in _Nanolib:
_Nanolib.ResultBusHwIds_swigregister(ResultBusHwIds)
class ResultDeviceId(Result):
    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):
        _Nanolib.ResultDeviceId_swiginit(self, _Nanolib.new_ResultDeviceId(*args))
    __swig_destroy__ = _Nanolib.delete_ResultDeviceId

    def getResult(self):
        return _Nanolib.ResultDeviceId_getResult(self)

# Register ResultDeviceId in _Nanolib:
_Nanolib.ResultDeviceId_swigregister(ResultDeviceId)
class ResultDeviceIds(Result):
    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):
        _Nanolib.ResultDeviceIds_swiginit(self, _Nanolib.new_ResultDeviceIds(*args))
    __swig_destroy__ = _Nanolib.delete_ResultDeviceIds

    def getResult(self):
        return _Nanolib.ResultDeviceIds_getResult(self)

# Register ResultDeviceIds in _Nanolib:
_Nanolib.ResultDeviceIds_swigregister(ResultDeviceIds)
class ResultDeviceHandle(Result):
    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):
        _Nanolib.ResultDeviceHandle_swiginit(self, _Nanolib.new_ResultDeviceHandle(*args))
    __swig_destroy__ = _Nanolib.delete_ResultDeviceHandle

    def getResult(self):
        return _Nanolib.ResultDeviceHandle_getResult(self)

# Register ResultDeviceHandle in _Nanolib:
_Nanolib.ResultDeviceHandle_swigregister(ResultDeviceHandle)
class ResultConnectionState(Result):
    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):
        _Nanolib.ResultConnectionState_swiginit(self, _Nanolib.new_ResultConnectionState(*args))
    __swig_destroy__ = _Nanolib.delete_ResultConnectionState

    def getResult(self):
        return _Nanolib.ResultConnectionState_getResult(self)

# Register ResultConnectionState in _Nanolib:
_Nanolib.ResultConnectionState_swigregister(ResultConnectionState)
class ResultObjectEntry(Result):
    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):
        _Nanolib.ResultObjectEntry_swiginit(self, _Nanolib.new_ResultObjectEntry(*args))
    __swig_destroy__ = _Nanolib.delete_ResultObjectEntry

    def getResult(self):
        return _Nanolib.ResultObjectEntry_getResult(self)

# Register ResultObjectEntry in _Nanolib:
_Nanolib.ResultObjectEntry_swigregister(ResultObjectEntry)
class ResultObjectSubEntry(Result):
    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):
        _Nanolib.ResultObjectSubEntry_swiginit(self, _Nanolib.new_ResultObjectSubEntry(*args))
    __swig_destroy__ = _Nanolib.delete_ResultObjectSubEntry

    def getResult(self):
        return _Nanolib.ResultObjectSubEntry_getResult(self)

# Register ResultObjectSubEntry in _Nanolib:
_Nanolib.ResultObjectSubEntry_swigregister(ResultObjectSubEntry)
class ResultObjectDictionary(Result):
    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):
        _Nanolib.ResultObjectDictionary_swiginit(self, _Nanolib.new_ResultObjectDictionary(*args))
    __swig_destroy__ = _Nanolib.delete_ResultObjectDictionary

    def getResult(self):
        return _Nanolib.ResultObjectDictionary_getResult(self)

# Register ResultObjectDictionary in _Nanolib:
_Nanolib.ResultObjectDictionary_swigregister(ResultObjectDictionary)
class NlcCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Nanolib.delete_NlcCallback

    def callback(self):
        return _Nanolib.NlcCallback_callback(self)

    def __init__(self):
        if self.__class__ == NlcCallback:
            _self = None
        else:
            _self = self
        _Nanolib.NlcCallback_swiginit(self, _Nanolib.new_NlcCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _Nanolib.disown_NlcCallback(self)
        return weakref.proxy(self)

# Register NlcCallback in _Nanolib:
_Nanolib.NlcCallback_swigregister(NlcCallback)
class NlcDataTransferCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Nanolib.delete_NlcDataTransferCallback

    def callback(self, info, data):
        return _Nanolib.NlcDataTransferCallback_callback(self, info, data)

    def __init__(self):
        if self.__class__ == NlcDataTransferCallback:
            _self = None
        else:
            _self = self
        _Nanolib.NlcDataTransferCallback_swiginit(self, _Nanolib.new_NlcDataTransferCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _Nanolib.disown_NlcDataTransferCallback(self)
        return weakref.proxy(self)

# Register NlcDataTransferCallback in _Nanolib:
_Nanolib.NlcDataTransferCallback_swigregister(NlcDataTransferCallback)
class NlcScanBusCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Nanolib.delete_NlcScanBusCallback

    def callback(self, info, devicesFound, data):
        return _Nanolib.NlcScanBusCallback_callback(self, info, devicesFound, data)

    def __init__(self):
        if self.__class__ == NlcScanBusCallback:
            _self = None
        else:
            _self = self
        _Nanolib.NlcScanBusCallback_swiginit(self, _Nanolib.new_NlcScanBusCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _Nanolib.disown_NlcScanBusCallback(self)
        return weakref.proxy(self)

# Register NlcScanBusCallback in _Nanolib:
_Nanolib.NlcScanBusCallback_swigregister(NlcScanBusCallback)
class NlcLoggingCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Nanolib.delete_NlcLoggingCallback

    def callback(self, payload_str, formatted_str, logger_name, log_level, time_since_epoch, thread_id):
        return _Nanolib.NlcLoggingCallback_callback(self, payload_str, formatted_str, logger_name, log_level, time_since_epoch, thread_id)

    def __init__(self):
        if self.__class__ == NlcLoggingCallback:
            _self = None
        else:
            _self = self
        _Nanolib.NlcLoggingCallback_swiginit(self, _Nanolib.new_NlcLoggingCallback(_self, ))
    def __disown__(self):
        self.this.disown()
        _Nanolib.disown_NlcLoggingCallback(self)
        return weakref.proxy(self)

# Register NlcLoggingCallback in _Nanolib:
_Nanolib.NlcLoggingCallback_swigregister(NlcLoggingCallback)
class OdLibrary(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__ = _Nanolib.delete_OdLibrary

    def getObjectDictionaryCount(self):
        return _Nanolib.OdLibrary_getObjectDictionaryCount(self)

    def getObjectDictionary(self, odIndex):
        return _Nanolib.OdLibrary_getObjectDictionary(self, odIndex)

    def addObjectDictionaryFromFile(self, absoluteXmlFilePath):
        return _Nanolib.OdLibrary_addObjectDictionaryFromFile(self, absoluteXmlFilePath)

    def addObjectDictionary(self, *args):
        return _Nanolib.OdLibrary_addObjectDictionary(self, *args)

# Register OdLibrary in _Nanolib:
_Nanolib.OdLibrary_swigregister(OdLibrary)
class ProfinetDevice(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    deviceName = property(_Nanolib.ProfinetDevice_deviceName_get, _Nanolib.ProfinetDevice_deviceName_set)
    deviceVendor = property(_Nanolib.ProfinetDevice_deviceVendor_get, _Nanolib.ProfinetDevice_deviceVendor_set)
    macAddress = property(_Nanolib.ProfinetDevice_macAddress_get, _Nanolib.ProfinetDevice_macAddress_set)
    ipAddress = property(_Nanolib.ProfinetDevice_ipAddress_get, _Nanolib.ProfinetDevice_ipAddress_set)
    netMask = property(_Nanolib.ProfinetDevice_netMask_get, _Nanolib.ProfinetDevice_netMask_set)
    defaultGateway = property(_Nanolib.ProfinetDevice_defaultGateway_get, _Nanolib.ProfinetDevice_defaultGateway_set)

    def __init__(self):
        _Nanolib.ProfinetDevice_swiginit(self, _Nanolib.new_ProfinetDevice())
    __swig_destroy__ = _Nanolib.delete_ProfinetDevice

# Register ProfinetDevice in _Nanolib:
_Nanolib.ProfinetDevice_swigregister(ProfinetDevice)
class ResultProfinetDevices(Result):
    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):
        _Nanolib.ResultProfinetDevices_swiginit(self, _Nanolib.new_ResultProfinetDevices(*args))

    def getResult(self):
        return _Nanolib.ResultProfinetDevices_getResult(self)
    __swig_destroy__ = _Nanolib.delete_ResultProfinetDevices

# Register ResultProfinetDevices in _Nanolib:
_Nanolib.ResultProfinetDevices_swigregister(ResultProfinetDevices)
class ProfinetDCP(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__ = _Nanolib.delete_ProfinetDCP

    def getScanTimeout(self):
        return _Nanolib.ProfinetDCP_getScanTimeout(self)

    def setScanTimeout(self, timeoutMsec):
        return _Nanolib.ProfinetDCP_setScanTimeout(self, timeoutMsec)

    def getResponseTimeout(self):
        return _Nanolib.ProfinetDCP_getResponseTimeout(self)

    def setResponseTimeout(self, timeoutMsec):
        return _Nanolib.ProfinetDCP_setResponseTimeout(self, timeoutMsec)

    def isServiceAvailable(self, busHardwareId):
        return _Nanolib.ProfinetDCP_isServiceAvailable(self, busHardwareId)

    def scanProfinetDevices(self, busHardwareId):
        return _Nanolib.ProfinetDCP_scanProfinetDevices(self, busHardwareId)

    def setupProfinetDevice(self, busHardwareId, profinetDevice, savePermanent):
        return _Nanolib.ProfinetDCP_setupProfinetDevice(self, busHardwareId, profinetDevice, savePermanent)

    def resetProfinetDevice(self, busHardwareId, profinetDevice):
        return _Nanolib.ProfinetDCP_resetProfinetDevice(self, busHardwareId, profinetDevice)

    def blinkProfinetDevice(self, busHardwareId, profinetDevice):
        return _Nanolib.ProfinetDCP_blinkProfinetDevice(self, busHardwareId, profinetDevice)

    def validateProfinetDeviceIp(self, busHardwareId, profinetDevice):
        return _Nanolib.ProfinetDCP_validateProfinetDeviceIp(self, busHardwareId, profinetDevice)

# Register ProfinetDCP in _Nanolib:
_Nanolib.ProfinetDCP_swigregister(ProfinetDCP)
SamplerState_Unconfigured = _Nanolib.SamplerState_Unconfigured
SamplerState_Configured = _Nanolib.SamplerState_Configured
SamplerState_Ready = _Nanolib.SamplerState_Ready
SamplerState_Running = _Nanolib.SamplerState_Running
SamplerState_Completed = _Nanolib.SamplerState_Completed
SamplerState_Failed = _Nanolib.SamplerState_Failed
SamplerState_Cancelled = _Nanolib.SamplerState_Cancelled
class ResultSamplerState(Result):
    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):
        _Nanolib.ResultSamplerState_swiginit(self, _Nanolib.new_ResultSamplerState(*args))
    __swig_destroy__ = _Nanolib.delete_ResultSamplerState

    def getResult(self):
        return _Nanolib.ResultSamplerState_getResult(self)

# Register ResultSamplerState in _Nanolib:
_Nanolib.ResultSamplerState_swigregister(ResultSamplerState)
SamplerTriggerCondition_TC_FALSE = _Nanolib.SamplerTriggerCondition_TC_FALSE
SamplerTriggerCondition_TC_TRUE = _Nanolib.SamplerTriggerCondition_TC_TRUE
SamplerTriggerCondition_TC_SET = _Nanolib.SamplerTriggerCondition_TC_SET
SamplerTriggerCondition_TC_CLEAR = _Nanolib.SamplerTriggerCondition_TC_CLEAR
SamplerTriggerCondition_TC_RISING_EDGE = _Nanolib.SamplerTriggerCondition_TC_RISING_EDGE
SamplerTriggerCondition_TC_FALLING_EDGE = _Nanolib.SamplerTriggerCondition_TC_FALLING_EDGE
SamplerTriggerCondition_TC_BIT_TOGGLE = _Nanolib.SamplerTriggerCondition_TC_BIT_TOGGLE
SamplerTriggerCondition_TC_GREATER = _Nanolib.SamplerTriggerCondition_TC_GREATER
SamplerTriggerCondition_TC_GREATER_OR_EQUAL = _Nanolib.SamplerTriggerCondition_TC_GREATER_OR_EQUAL
SamplerTriggerCondition_TC_LESS = _Nanolib.SamplerTriggerCondition_TC_LESS
SamplerTriggerCondition_TC_LESS_OR_EQUAL = _Nanolib.SamplerTriggerCondition_TC_LESS_OR_EQUAL
SamplerTriggerCondition_TC_EQUAL = _Nanolib.SamplerTriggerCondition_TC_EQUAL
SamplerTriggerCondition_TC_NOT_EQUAL = _Nanolib.SamplerTriggerCondition_TC_NOT_EQUAL
SamplerTriggerCondition_TC_ONE_EDGE = _Nanolib.SamplerTriggerCondition_TC_ONE_EDGE
SamplerTriggerCondition_TC_MULTI_EDGE = _Nanolib.SamplerTriggerCondition_TC_MULTI_EDGE
SamplerMode_Normal = _Nanolib.SamplerMode_Normal
SamplerMode_Repetitive = _Nanolib.SamplerMode_Repetitive
SamplerMode_Continuous = _Nanolib.SamplerMode_Continuous
class SamplerTrigger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    condition = property(_Nanolib.SamplerTrigger_condition_get, _Nanolib.SamplerTrigger_condition_set)
    address = property(_Nanolib.SamplerTrigger_address_get, _Nanolib.SamplerTrigger_address_set)
    value = property(_Nanolib.SamplerTrigger_value_get, _Nanolib.SamplerTrigger_value_set)

    def __init__(self):
        _Nanolib.SamplerTrigger_swiginit(self, _Nanolib.new_SamplerTrigger())
    __swig_destroy__ = _Nanolib.delete_SamplerTrigger

# Register SamplerTrigger in _Nanolib:
_Nanolib.SamplerTrigger_swigregister(SamplerTrigger)
class SamplerConfiguration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    version = property(_Nanolib.SamplerConfiguration_version_get, _Nanolib.SamplerConfiguration_version_set)
    SAMPLER_CONFIGURATION_VERSION = _Nanolib.SamplerConfiguration_SAMPLER_CONFIGURATION_VERSION
    mode = property(_Nanolib.SamplerConfiguration_mode_get, _Nanolib.SamplerConfiguration_mode_set)
    usingSoftwareImplementation = property(_Nanolib.SamplerConfiguration_usingSoftwareImplementation_get, _Nanolib.SamplerConfiguration_usingSoftwareImplementation_set)
    usingNewFWSamplerImplementation = property(_Nanolib.SamplerConfiguration_usingNewFWSamplerImplementation_get, _Nanolib.SamplerConfiguration_usingNewFWSamplerImplementation_set)
    periodMilliseconds = property(_Nanolib.SamplerConfiguration_periodMilliseconds_get, _Nanolib.SamplerConfiguration_periodMilliseconds_set)
    durationMilliseconds = property(_Nanolib.SamplerConfiguration_durationMilliseconds_get, _Nanolib.SamplerConfiguration_durationMilliseconds_set)
    preTriggerNumberOfSamples = property(_Nanolib.SamplerConfiguration_preTriggerNumberOfSamples_get, _Nanolib.SamplerConfiguration_preTriggerNumberOfSamples_set)
    startTrigger = property(_Nanolib.SamplerConfiguration_startTrigger_get, _Nanolib.SamplerConfiguration_startTrigger_set)
    stopTrigger = property(_Nanolib.SamplerConfiguration_stopTrigger_get, _Nanolib.SamplerConfiguration_stopTrigger_set)
    trackedAddresses = property(_Nanolib.SamplerConfiguration_trackedAddresses_get, _Nanolib.SamplerConfiguration_trackedAddresses_set)
    MAX_TRACKED_ADDRESSES = _Nanolib.SamplerConfiguration_MAX_TRACKED_ADDRESSES

    def __init__(self):
        _Nanolib.SamplerConfiguration_swiginit(self, _Nanolib.new_SamplerConfiguration())
    __swig_destroy__ = _Nanolib.delete_SamplerConfiguration

# Register SamplerConfiguration in _Nanolib:
_Nanolib.SamplerConfiguration_swigregister(SamplerConfiguration)
class SampledValue(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    value = property(_Nanolib.SampledValue_value_get, _Nanolib.SampledValue_value_set)
    collectTimeMsec = property(_Nanolib.SampledValue_collectTimeMsec_get, _Nanolib.SampledValue_collectTimeMsec_set)

    def __init__(self):
        _Nanolib.SampledValue_swiginit(self, _Nanolib.new_SampledValue())
    __swig_destroy__ = _Nanolib.delete_SampledValue

# Register SampledValue in _Nanolib:
_Nanolib.SampledValue_swigregister(SampledValue)
class SampleData(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterationNumber = property(_Nanolib.SampleData_iterationNumber_get, _Nanolib.SampleData_iterationNumber_set)
    sampledValues = property(_Nanolib.SampleData_sampledValues_get, _Nanolib.SampleData_sampledValues_set)

    def __init__(self):
        _Nanolib.SampleData_swiginit(self, _Nanolib.new_SampleData())
    __swig_destroy__ = _Nanolib.delete_SampleData

# Register SampleData in _Nanolib:
_Nanolib.SampleData_swigregister(SampleData)
class ResultSampleDataArray(Result):
    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):
        _Nanolib.ResultSampleDataArray_swiginit(self, _Nanolib.new_ResultSampleDataArray(*args))
    __swig_destroy__ = _Nanolib.delete_ResultSampleDataArray

    def getResult(self):
        return _Nanolib.ResultSampleDataArray_getResult(self)

# Register ResultSampleDataArray in _Nanolib:
_Nanolib.ResultSampleDataArray_swigregister(ResultSampleDataArray)
class SamplerNotify(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _Nanolib.delete_SamplerNotify

    def notify(self, lastError, samplerState, sampleDatas, applicationData):
        return _Nanolib.SamplerNotify_notify(self, lastError, samplerState, sampleDatas, applicationData)

    def __init__(self):
        if self.__class__ == SamplerNotify:
            _self = None
        else:
            _self = self
        _Nanolib.SamplerNotify_swiginit(self, _Nanolib.new_SamplerNotify(_self, ))
    def __disown__(self):
        self.this.disown()
        _Nanolib.disown_SamplerNotify(self)
        return weakref.proxy(self)

# Register SamplerNotify in _Nanolib:
_Nanolib.SamplerNotify_swigregister(SamplerNotify)
class SamplerInterface(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__ = _Nanolib.delete_SamplerInterface

    def configure(self, deviceHandle, samplerConfiguration):
        return _Nanolib.SamplerInterface_configure(self, deviceHandle, samplerConfiguration)

    def start(self, deviceHandle, samplerNotify, applicationData):
        return _Nanolib.SamplerInterface_start(self, deviceHandle, samplerNotify, applicationData)

    def getData(self, deviceHandle):
        return _Nanolib.SamplerInterface_getData(self, deviceHandle)

    def stop(self, deviceHandle):
        return _Nanolib.SamplerInterface_stop(self, deviceHandle)

    def getState(self, deviceHandle):
        return _Nanolib.SamplerInterface_getState(self, deviceHandle)

    def getLastError(self, deviceHandle):
        return _Nanolib.SamplerInterface_getLastError(self, deviceHandle)

# Register SamplerInterface in _Nanolib:
_Nanolib.SamplerInterface_swigregister(SamplerInterface)
class ObjectDictionary(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Nanolib.ObjectDictionary_swiginit(self, _Nanolib.new_ObjectDictionary())
    __swig_destroy__ = _Nanolib.delete_ObjectDictionary

    def getXmlFileName(self):
        return _Nanolib.ObjectDictionary_getXmlFileName(self)

    def getDeviceHandle(self):
        return _Nanolib.ObjectDictionary_getDeviceHandle(self)

    def getObject(self, odIndex):
        return _Nanolib.ObjectDictionary_getObject(self, odIndex)

    def getObjectEntry(self, index):
        return _Nanolib.ObjectDictionary_getObjectEntry(self, index)

    def readNumber(self, odIndex):
        return _Nanolib.ObjectDictionary_readNumber(self, odIndex)

    def readString(self, odIndex):
        return _Nanolib.ObjectDictionary_readString(self, odIndex)

    def readBytes(self, odIndex):
        return _Nanolib.ObjectDictionary_readBytes(self, odIndex)

    def writeNumber(self, odIndex, value):
        return _Nanolib.ObjectDictionary_writeNumber(self, odIndex, value)

    def writeBytes(self, odIndex, data):
        return _Nanolib.ObjectDictionary_writeBytes(self, odIndex, data)

    def readNumberArray(self, index):
        return _Nanolib.ObjectDictionary_readNumberArray(self, index)

# Register ObjectDictionary in _Nanolib:
_Nanolib.ObjectDictionary_swigregister(ObjectDictionary)
class ObjectEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Nanolib.ObjectEntry_swiginit(self, _Nanolib.new_ObjectEntry())
    __swig_destroy__ = _Nanolib.delete_ObjectEntry

    def getName(self):
        return _Nanolib.ObjectEntry_getName(self)

    def getPrivate(self):
        return _Nanolib.ObjectEntry_getPrivate(self)

    def getIndex(self):
        return _Nanolib.ObjectEntry_getIndex(self)

    def getDataType(self):
        return _Nanolib.ObjectEntry_getDataType(self)

    def getObjectCode(self):
        return _Nanolib.ObjectEntry_getObjectCode(self)

    def getObjectSaveable(self):
        return _Nanolib.ObjectEntry_getObjectSaveable(self)

    def getMaxSubIndex(self):
        return _Nanolib.ObjectEntry_getMaxSubIndex(self)

    def getSubEntry(self, subIndex):
        return _Nanolib.ObjectEntry_getSubEntry(self, subIndex)

# Register ObjectEntry in _Nanolib:
_Nanolib.ObjectEntry_swigregister(ObjectEntry)
class ObjectSubEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _Nanolib.ObjectSubEntry_swiginit(self, _Nanolib.new_ObjectSubEntry())
    __swig_destroy__ = _Nanolib.delete_ObjectSubEntry

    def getName(self):
        return _Nanolib.ObjectSubEntry_getName(self)

    def getSubIndex(self):
        return _Nanolib.ObjectSubEntry_getSubIndex(self)

    def getDataType(self):
        return _Nanolib.ObjectSubEntry_getDataType(self)

    def getSdoAccess(self):
        return _Nanolib.ObjectSubEntry_getSdoAccess(self)

    def getPdoAccess(self):
        return _Nanolib.ObjectSubEntry_getPdoAccess(self)

    def getBitLength(self):
        return _Nanolib.ObjectSubEntry_getBitLength(self)

    def getDefaultValueAsNumeric(self, key):
        return _Nanolib.ObjectSubEntry_getDefaultValueAsNumeric(self, key)

    def getDefaultValueAsString(self, key):
        return _Nanolib.ObjectSubEntry_getDefaultValueAsString(self, key)

    def getDefaultValues(self):
        return _Nanolib.ObjectSubEntry_getDefaultValues(self)

    def readNumber(self):
        return _Nanolib.ObjectSubEntry_readNumber(self)

    def readString(self):
        return _Nanolib.ObjectSubEntry_readString(self)

    def readBytes(self):
        return _Nanolib.ObjectSubEntry_readBytes(self)

    def writeNumber(self, value):
        return _Nanolib.ObjectSubEntry_writeNumber(self, value)

    def writeBytes(self, data):
        return _Nanolib.ObjectSubEntry_writeBytes(self, data)

# Register ObjectSubEntry in _Nanolib:
_Nanolib.ObjectSubEntry_swigregister(ObjectSubEntry)
class MacAddress(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.MacAddress_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.MacAddress___nonzero__(self)

    def __bool__(self):
        return _Nanolib.MacAddress___bool__(self)

    def __len__(self):
        return _Nanolib.MacAddress___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.MacAddress___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.MacAddress___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.MacAddress___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.MacAddress___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.MacAddress___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.MacAddress___setitem__(self, *args)

    def __init__(self, *args):
        _Nanolib.MacAddress_swiginit(self, _Nanolib.new_MacAddress(*args))

    def empty(self):
        return _Nanolib.MacAddress_empty(self)

    def size(self):
        return _Nanolib.MacAddress_size(self)

    def swap(self, v):
        return _Nanolib.MacAddress_swap(self, v)

    def begin(self):
        return _Nanolib.MacAddress_begin(self)

    def end(self):
        return _Nanolib.MacAddress_end(self)

    def rbegin(self):
        return _Nanolib.MacAddress_rbegin(self)

    def rend(self):
        return _Nanolib.MacAddress_rend(self)

    def front(self):
        return _Nanolib.MacAddress_front(self)

    def back(self):
        return _Nanolib.MacAddress_back(self)

    def fill(self, u):
        return _Nanolib.MacAddress_fill(self, u)
    __swig_destroy__ = _Nanolib.delete_MacAddress

# Register MacAddress in _Nanolib:
_Nanolib.MacAddress_swigregister(MacAddress)
BUS_HARDWARE_ID_PROTOCOL_CANOPEN = cvar.BUS_HARDWARE_ID_PROTOCOL_CANOPEN
BUS_HARDWARE_ID_IXXAT = cvar.BUS_HARDWARE_ID_IXXAT
BUS_HARDWARE_ID_ZK_USB_CAN = cvar.BUS_HARDWARE_ID_ZK_USB_CAN
BUS_HARDWARE_ID_PROTOCOL_MODBUS_RTU = cvar.BUS_HARDWARE_ID_PROTOCOL_MODBUS_RTU
BUS_HARDWARE_ID_SERIAL_PORT = cvar.BUS_HARDWARE_ID_SERIAL_PORT
BUS_HARDWARE_ID_PROTOCOL_MODBUS_VCP = cvar.BUS_HARDWARE_ID_PROTOCOL_MODBUS_VCP
BUS_HARDWARE_ID_PROTOCOL_MSC = cvar.BUS_HARDWARE_ID_PROTOCOL_MSC
BUS_HARDWARE_ID_NANOTEC_VCP = cvar.BUS_HARDWARE_ID_NANOTEC_VCP
BUS_HARDWARE_ID_USB_BUS = cvar.BUS_HARDWARE_ID_USB_BUS
BUS_HARDWARE_ID_PROTOCOL_MODBUS_TCP = cvar.BUS_HARDWARE_ID_PROTOCOL_MODBUS_TCP
BUS_HARDWARE_ID_NETWORK = cvar.BUS_HARDWARE_ID_NETWORK
BUS_HARDWARE_ID_PROTOCOL_RESTFULL_API = cvar.BUS_HARDWARE_ID_PROTOCOL_RESTFULL_API
BUS_HARDWARE_ID_PROTOCOL_ETHERCAT = cvar.BUS_HARDWARE_ID_PROTOCOL_ETHERCAT

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

    def iterator(self):
        return _Nanolib.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.IntVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.IntVector___bool__(self)

    def __len__(self):
        return _Nanolib.IntVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.IntVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.IntVector_pop(self)

    def append(self, x):
        return _Nanolib.IntVector_append(self, x)

    def empty(self):
        return _Nanolib.IntVector_empty(self)

    def size(self):
        return _Nanolib.IntVector_size(self)

    def swap(self, v):
        return _Nanolib.IntVector_swap(self, v)

    def begin(self):
        return _Nanolib.IntVector_begin(self)

    def end(self):
        return _Nanolib.IntVector_end(self)

    def rbegin(self):
        return _Nanolib.IntVector_rbegin(self)

    def rend(self):
        return _Nanolib.IntVector_rend(self)

    def clear(self):
        return _Nanolib.IntVector_clear(self)

    def get_allocator(self):
        return _Nanolib.IntVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.IntVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.IntVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.IntVector_swiginit(self, _Nanolib.new_IntVector(*args))

    def push_back(self, x):
        return _Nanolib.IntVector_push_back(self, x)

    def front(self):
        return _Nanolib.IntVector_front(self)

    def back(self):
        return _Nanolib.IntVector_back(self)

    def assign(self, n, x):
        return _Nanolib.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _Nanolib.IntVector_resize(self, *args)

    def insert(self, *args):
        return _Nanolib.IntVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.IntVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.IntVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_IntVector

# Register IntVector in _Nanolib:
_Nanolib.IntVector_swigregister(IntVector)
class ByteVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.ByteVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.ByteVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.ByteVector___bool__(self)

    def __len__(self):
        return _Nanolib.ByteVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.ByteVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.ByteVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.ByteVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.ByteVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.ByteVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.ByteVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.ByteVector_pop(self)

    def append(self, x):
        return _Nanolib.ByteVector_append(self, x)

    def empty(self):
        return _Nanolib.ByteVector_empty(self)

    def size(self):
        return _Nanolib.ByteVector_size(self)

    def swap(self, v):
        return _Nanolib.ByteVector_swap(self, v)

    def begin(self):
        return _Nanolib.ByteVector_begin(self)

    def end(self):
        return _Nanolib.ByteVector_end(self)

    def rbegin(self):
        return _Nanolib.ByteVector_rbegin(self)

    def rend(self):
        return _Nanolib.ByteVector_rend(self)

    def clear(self):
        return _Nanolib.ByteVector_clear(self)

    def get_allocator(self):
        return _Nanolib.ByteVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.ByteVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.ByteVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.ByteVector_swiginit(self, _Nanolib.new_ByteVector(*args))

    def push_back(self, x):
        return _Nanolib.ByteVector_push_back(self, x)

    def front(self):
        return _Nanolib.ByteVector_front(self)

    def back(self):
        return _Nanolib.ByteVector_back(self)

    def assign(self, n, x):
        return _Nanolib.ByteVector_assign(self, n, x)

    def resize(self, *args):
        return _Nanolib.ByteVector_resize(self, *args)

    def insert(self, *args):
        return _Nanolib.ByteVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.ByteVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.ByteVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_ByteVector

# Register ByteVector in _Nanolib:
_Nanolib.ByteVector_swigregister(ByteVector)
class BusHWIdVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.BusHWIdVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.BusHWIdVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.BusHWIdVector___bool__(self)

    def __len__(self):
        return _Nanolib.BusHWIdVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.BusHWIdVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.BusHWIdVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.BusHWIdVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.BusHWIdVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.BusHWIdVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.BusHWIdVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.BusHWIdVector_pop(self)

    def append(self, x):
        return _Nanolib.BusHWIdVector_append(self, x)

    def empty(self):
        return _Nanolib.BusHWIdVector_empty(self)

    def size(self):
        return _Nanolib.BusHWIdVector_size(self)

    def swap(self, v):
        return _Nanolib.BusHWIdVector_swap(self, v)

    def begin(self):
        return _Nanolib.BusHWIdVector_begin(self)

    def end(self):
        return _Nanolib.BusHWIdVector_end(self)

    def rbegin(self):
        return _Nanolib.BusHWIdVector_rbegin(self)

    def rend(self):
        return _Nanolib.BusHWIdVector_rend(self)

    def clear(self):
        return _Nanolib.BusHWIdVector_clear(self)

    def get_allocator(self):
        return _Nanolib.BusHWIdVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.BusHWIdVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.BusHWIdVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.BusHWIdVector_swiginit(self, _Nanolib.new_BusHWIdVector(*args))

    def push_back(self, x):
        return _Nanolib.BusHWIdVector_push_back(self, x)

    def front(self):
        return _Nanolib.BusHWIdVector_front(self)

    def back(self):
        return _Nanolib.BusHWIdVector_back(self)

    def assign(self, n, x):
        return _Nanolib.BusHWIdVector_assign(self, n, x)

    def insert(self, *args):
        return _Nanolib.BusHWIdVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.BusHWIdVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.BusHWIdVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_BusHWIdVector

# Register BusHWIdVector in _Nanolib:
_Nanolib.BusHWIdVector_swigregister(BusHWIdVector)
class DeviceIdVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.DeviceIdVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.DeviceIdVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.DeviceIdVector___bool__(self)

    def __len__(self):
        return _Nanolib.DeviceIdVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.DeviceIdVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.DeviceIdVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.DeviceIdVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.DeviceIdVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.DeviceIdVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.DeviceIdVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.DeviceIdVector_pop(self)

    def append(self, x):
        return _Nanolib.DeviceIdVector_append(self, x)

    def empty(self):
        return _Nanolib.DeviceIdVector_empty(self)

    def size(self):
        return _Nanolib.DeviceIdVector_size(self)

    def swap(self, v):
        return _Nanolib.DeviceIdVector_swap(self, v)

    def begin(self):
        return _Nanolib.DeviceIdVector_begin(self)

    def end(self):
        return _Nanolib.DeviceIdVector_end(self)

    def rbegin(self):
        return _Nanolib.DeviceIdVector_rbegin(self)

    def rend(self):
        return _Nanolib.DeviceIdVector_rend(self)

    def clear(self):
        return _Nanolib.DeviceIdVector_clear(self)

    def get_allocator(self):
        return _Nanolib.DeviceIdVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.DeviceIdVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.DeviceIdVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.DeviceIdVector_swiginit(self, _Nanolib.new_DeviceIdVector(*args))

    def push_back(self, x):
        return _Nanolib.DeviceIdVector_push_back(self, x)

    def front(self):
        return _Nanolib.DeviceIdVector_front(self)

    def back(self):
        return _Nanolib.DeviceIdVector_back(self)

    def assign(self, n, x):
        return _Nanolib.DeviceIdVector_assign(self, n, x)

    def insert(self, *args):
        return _Nanolib.DeviceIdVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.DeviceIdVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.DeviceIdVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_DeviceIdVector

# Register DeviceIdVector in _Nanolib:
_Nanolib.DeviceIdVector_swigregister(DeviceIdVector)
class ProfinetDeviceVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.ProfinetDeviceVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.ProfinetDeviceVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.ProfinetDeviceVector___bool__(self)

    def __len__(self):
        return _Nanolib.ProfinetDeviceVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.ProfinetDeviceVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.ProfinetDeviceVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.ProfinetDeviceVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.ProfinetDeviceVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.ProfinetDeviceVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.ProfinetDeviceVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.ProfinetDeviceVector_pop(self)

    def append(self, x):
        return _Nanolib.ProfinetDeviceVector_append(self, x)

    def empty(self):
        return _Nanolib.ProfinetDeviceVector_empty(self)

    def size(self):
        return _Nanolib.ProfinetDeviceVector_size(self)

    def swap(self, v):
        return _Nanolib.ProfinetDeviceVector_swap(self, v)

    def begin(self):
        return _Nanolib.ProfinetDeviceVector_begin(self)

    def end(self):
        return _Nanolib.ProfinetDeviceVector_end(self)

    def rbegin(self):
        return _Nanolib.ProfinetDeviceVector_rbegin(self)

    def rend(self):
        return _Nanolib.ProfinetDeviceVector_rend(self)

    def clear(self):
        return _Nanolib.ProfinetDeviceVector_clear(self)

    def get_allocator(self):
        return _Nanolib.ProfinetDeviceVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.ProfinetDeviceVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.ProfinetDeviceVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.ProfinetDeviceVector_swiginit(self, _Nanolib.new_ProfinetDeviceVector(*args))

    def push_back(self, x):
        return _Nanolib.ProfinetDeviceVector_push_back(self, x)

    def front(self):
        return _Nanolib.ProfinetDeviceVector_front(self)

    def back(self):
        return _Nanolib.ProfinetDeviceVector_back(self)

    def assign(self, n, x):
        return _Nanolib.ProfinetDeviceVector_assign(self, n, x)

    def insert(self, *args):
        return _Nanolib.ProfinetDeviceVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.ProfinetDeviceVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.ProfinetDeviceVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_ProfinetDeviceVector

# Register ProfinetDeviceVector in _Nanolib:
_Nanolib.ProfinetDeviceVector_swigregister(ProfinetDeviceVector)
class OdIndexVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.OdIndexVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.OdIndexVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.OdIndexVector___bool__(self)

    def __len__(self):
        return _Nanolib.OdIndexVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.OdIndexVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.OdIndexVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.OdIndexVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.OdIndexVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.OdIndexVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.OdIndexVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.OdIndexVector_pop(self)

    def append(self, x):
        return _Nanolib.OdIndexVector_append(self, x)

    def empty(self):
        return _Nanolib.OdIndexVector_empty(self)

    def size(self):
        return _Nanolib.OdIndexVector_size(self)

    def swap(self, v):
        return _Nanolib.OdIndexVector_swap(self, v)

    def begin(self):
        return _Nanolib.OdIndexVector_begin(self)

    def end(self):
        return _Nanolib.OdIndexVector_end(self)

    def rbegin(self):
        return _Nanolib.OdIndexVector_rbegin(self)

    def rend(self):
        return _Nanolib.OdIndexVector_rend(self)

    def clear(self):
        return _Nanolib.OdIndexVector_clear(self)

    def get_allocator(self):
        return _Nanolib.OdIndexVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.OdIndexVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.OdIndexVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.OdIndexVector_swiginit(self, _Nanolib.new_OdIndexVector(*args))

    def push_back(self, x):
        return _Nanolib.OdIndexVector_push_back(self, x)

    def front(self):
        return _Nanolib.OdIndexVector_front(self)

    def back(self):
        return _Nanolib.OdIndexVector_back(self)

    def assign(self, n, x):
        return _Nanolib.OdIndexVector_assign(self, n, x)

    def insert(self, *args):
        return _Nanolib.OdIndexVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.OdIndexVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.OdIndexVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_OdIndexVector

# Register OdIndexVector in _Nanolib:
_Nanolib.OdIndexVector_swigregister(OdIndexVector)
class SampleDataVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.SampleDataVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.SampleDataVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.SampleDataVector___bool__(self)

    def __len__(self):
        return _Nanolib.SampleDataVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.SampleDataVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.SampleDataVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.SampleDataVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.SampleDataVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.SampleDataVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.SampleDataVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.SampleDataVector_pop(self)

    def append(self, x):
        return _Nanolib.SampleDataVector_append(self, x)

    def empty(self):
        return _Nanolib.SampleDataVector_empty(self)

    def size(self):
        return _Nanolib.SampleDataVector_size(self)

    def swap(self, v):
        return _Nanolib.SampleDataVector_swap(self, v)

    def begin(self):
        return _Nanolib.SampleDataVector_begin(self)

    def end(self):
        return _Nanolib.SampleDataVector_end(self)

    def rbegin(self):
        return _Nanolib.SampleDataVector_rbegin(self)

    def rend(self):
        return _Nanolib.SampleDataVector_rend(self)

    def clear(self):
        return _Nanolib.SampleDataVector_clear(self)

    def get_allocator(self):
        return _Nanolib.SampleDataVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.SampleDataVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.SampleDataVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.SampleDataVector_swiginit(self, _Nanolib.new_SampleDataVector(*args))

    def push_back(self, x):
        return _Nanolib.SampleDataVector_push_back(self, x)

    def front(self):
        return _Nanolib.SampleDataVector_front(self)

    def back(self):
        return _Nanolib.SampleDataVector_back(self)

    def assign(self, n, x):
        return _Nanolib.SampleDataVector_assign(self, n, x)

    def insert(self, *args):
        return _Nanolib.SampleDataVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.SampleDataVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.SampleDataVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_SampleDataVector

# Register SampleDataVector in _Nanolib:
_Nanolib.SampleDataVector_swigregister(SampleDataVector)
class SampledValueVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.SampledValueVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.SampledValueVector___nonzero__(self)

    def __bool__(self):
        return _Nanolib.SampledValueVector___bool__(self)

    def __len__(self):
        return _Nanolib.SampledValueVector___len__(self)

    def __getslice__(self, i, j):
        return _Nanolib.SampledValueVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _Nanolib.SampledValueVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _Nanolib.SampledValueVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _Nanolib.SampledValueVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _Nanolib.SampledValueVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _Nanolib.SampledValueVector___setitem__(self, *args)

    def pop(self):
        return _Nanolib.SampledValueVector_pop(self)

    def append(self, x):
        return _Nanolib.SampledValueVector_append(self, x)

    def empty(self):
        return _Nanolib.SampledValueVector_empty(self)

    def size(self):
        return _Nanolib.SampledValueVector_size(self)

    def swap(self, v):
        return _Nanolib.SampledValueVector_swap(self, v)

    def begin(self):
        return _Nanolib.SampledValueVector_begin(self)

    def end(self):
        return _Nanolib.SampledValueVector_end(self)

    def rbegin(self):
        return _Nanolib.SampledValueVector_rbegin(self)

    def rend(self):
        return _Nanolib.SampledValueVector_rend(self)

    def clear(self):
        return _Nanolib.SampledValueVector_clear(self)

    def get_allocator(self):
        return _Nanolib.SampledValueVector_get_allocator(self)

    def pop_back(self):
        return _Nanolib.SampledValueVector_pop_back(self)

    def erase(self, *args):
        return _Nanolib.SampledValueVector_erase(self, *args)

    def __init__(self, *args):
        _Nanolib.SampledValueVector_swiginit(self, _Nanolib.new_SampledValueVector(*args))

    def push_back(self, x):
        return _Nanolib.SampledValueVector_push_back(self, x)

    def front(self):
        return _Nanolib.SampledValueVector_front(self)

    def back(self):
        return _Nanolib.SampledValueVector_back(self)

    def assign(self, n, x):
        return _Nanolib.SampledValueVector_assign(self, n, x)

    def insert(self, *args):
        return _Nanolib.SampledValueVector_insert(self, *args)

    def reserve(self, n):
        return _Nanolib.SampledValueVector_reserve(self, n)

    def capacity(self):
        return _Nanolib.SampledValueVector_capacity(self)
    __swig_destroy__ = _Nanolib.delete_SampledValueVector

# Register SampledValueVector in _Nanolib:
_Nanolib.SampledValueVector_swigregister(SampledValueVector)
class StringIntMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.StringIntMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.StringIntMap___nonzero__(self)

    def __bool__(self):
        return _Nanolib.StringIntMap___bool__(self)

    def __len__(self):
        return _Nanolib.StringIntMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _Nanolib.StringIntMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Nanolib.StringIntMap___delitem__(self, key)

    def has_key(self, key):
        return _Nanolib.StringIntMap_has_key(self, key)

    def keys(self):
        return _Nanolib.StringIntMap_keys(self)

    def values(self):
        return _Nanolib.StringIntMap_values(self)

    def items(self):
        return _Nanolib.StringIntMap_items(self)

    def __contains__(self, key):
        return _Nanolib.StringIntMap___contains__(self, key)

    def key_iterator(self):
        return _Nanolib.StringIntMap_key_iterator(self)

    def value_iterator(self):
        return _Nanolib.StringIntMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Nanolib.StringIntMap___setitem__(self, *args)

    def asdict(self):
        return _Nanolib.StringIntMap_asdict(self)

    def __init__(self, *args):
        _Nanolib.StringIntMap_swiginit(self, _Nanolib.new_StringIntMap(*args))

    def empty(self):
        return _Nanolib.StringIntMap_empty(self)

    def size(self):
        return _Nanolib.StringIntMap_size(self)

    def swap(self, v):
        return _Nanolib.StringIntMap_swap(self, v)

    def begin(self):
        return _Nanolib.StringIntMap_begin(self)

    def end(self):
        return _Nanolib.StringIntMap_end(self)

    def rbegin(self):
        return _Nanolib.StringIntMap_rbegin(self)

    def rend(self):
        return _Nanolib.StringIntMap_rend(self)

    def clear(self):
        return _Nanolib.StringIntMap_clear(self)

    def get_allocator(self):
        return _Nanolib.StringIntMap_get_allocator(self)

    def count(self, x):
        return _Nanolib.StringIntMap_count(self, x)

    def erase(self, *args):
        return _Nanolib.StringIntMap_erase(self, *args)

    def find(self, x):
        return _Nanolib.StringIntMap_find(self, x)

    def lower_bound(self, x):
        return _Nanolib.StringIntMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Nanolib.StringIntMap_upper_bound(self, x)
    __swig_destroy__ = _Nanolib.delete_StringIntMap

# Register StringIntMap in _Nanolib:
_Nanolib.StringIntMap_swigregister(StringIntMap)
class StringStringMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _Nanolib.StringStringMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _Nanolib.StringStringMap___nonzero__(self)

    def __bool__(self):
        return _Nanolib.StringStringMap___bool__(self)

    def __len__(self):
        return _Nanolib.StringStringMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _Nanolib.StringStringMap___getitem__(self, key)

    def __delitem__(self, key):
        return _Nanolib.StringStringMap___delitem__(self, key)

    def has_key(self, key):
        return _Nanolib.StringStringMap_has_key(self, key)

    def keys(self):
        return _Nanolib.StringStringMap_keys(self)

    def values(self):
        return _Nanolib.StringStringMap_values(self)

    def items(self):
        return _Nanolib.StringStringMap_items(self)

    def __contains__(self, key):
        return _Nanolib.StringStringMap___contains__(self, key)

    def key_iterator(self):
        return _Nanolib.StringStringMap_key_iterator(self)

    def value_iterator(self):
        return _Nanolib.StringStringMap_value_iterator(self)

    def __setitem__(self, *args):
        return _Nanolib.StringStringMap___setitem__(self, *args)

    def asdict(self):
        return _Nanolib.StringStringMap_asdict(self)

    def __init__(self, *args):
        _Nanolib.StringStringMap_swiginit(self, _Nanolib.new_StringStringMap(*args))

    def empty(self):
        return _Nanolib.StringStringMap_empty(self)

    def size(self):
        return _Nanolib.StringStringMap_size(self)

    def swap(self, v):
        return _Nanolib.StringStringMap_swap(self, v)

    def begin(self):
        return _Nanolib.StringStringMap_begin(self)

    def end(self):
        return _Nanolib.StringStringMap_end(self)

    def rbegin(self):
        return _Nanolib.StringStringMap_rbegin(self)

    def rend(self):
        return _Nanolib.StringStringMap_rend(self)

    def clear(self):
        return _Nanolib.StringStringMap_clear(self)

    def get_allocator(self):
        return _Nanolib.StringStringMap_get_allocator(self)

    def count(self, x):
        return _Nanolib.StringStringMap_count(self, x)

    def erase(self, *args):
        return _Nanolib.StringStringMap_erase(self, *args)

    def find(self, x):
        return _Nanolib.StringStringMap_find(self, x)

    def lower_bound(self, x):
        return _Nanolib.StringStringMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _Nanolib.StringStringMap_upper_bound(self, x)
    __swig_destroy__ = _Nanolib.delete_StringStringMap

# Register StringStringMap in _Nanolib:
_Nanolib.StringStringMap_swigregister(StringStringMap)
class CanBaudRate(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BAUD_RATE_1000K = property(_Nanolib.CanBaudRate_BAUD_RATE_1000K_get)
    BAUD_RATE_800K = property(_Nanolib.CanBaudRate_BAUD_RATE_800K_get)
    BAUD_RATE_500K = property(_Nanolib.CanBaudRate_BAUD_RATE_500K_get)
    BAUD_RATE_250K = property(_Nanolib.CanBaudRate_BAUD_RATE_250K_get)
    BAUD_RATE_125K = property(_Nanolib.CanBaudRate_BAUD_RATE_125K_get)
    BAUD_RATE_100K = property(_Nanolib.CanBaudRate_BAUD_RATE_100K_get)
    BAUD_RATE_50K = property(_Nanolib.CanBaudRate_BAUD_RATE_50K_get)
    BAUD_RATE_20K = property(_Nanolib.CanBaudRate_BAUD_RATE_20K_get)
    BAUD_RATE_10K = property(_Nanolib.CanBaudRate_BAUD_RATE_10K_get)
    BAUD_RATE_5K = property(_Nanolib.CanBaudRate_BAUD_RATE_5K_get)

    def __init__(self):
        _Nanolib.CanBaudRate_swiginit(self, _Nanolib.new_CanBaudRate())
    __swig_destroy__ = _Nanolib.delete_CanBaudRate

# Register CanBaudRate in _Nanolib:
_Nanolib.CanBaudRate_swigregister(CanBaudRate)
class IxxatAdapterBusNumber(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BUS_NUMBER_0_DEFAULT = property(_Nanolib.IxxatAdapterBusNumber_BUS_NUMBER_0_DEFAULT_get)
    BUS_NUMBER_1 = property(_Nanolib.IxxatAdapterBusNumber_BUS_NUMBER_1_get)
    BUS_NUMBER_2 = property(_Nanolib.IxxatAdapterBusNumber_BUS_NUMBER_2_get)
    BUS_NUMBER_3 = property(_Nanolib.IxxatAdapterBusNumber_BUS_NUMBER_3_get)

    def __init__(self):
        _Nanolib.IxxatAdapterBusNumber_swiginit(self, _Nanolib.new_IxxatAdapterBusNumber())
    __swig_destroy__ = _Nanolib.delete_IxxatAdapterBusNumber

# Register IxxatAdapterBusNumber in _Nanolib:
_Nanolib.IxxatAdapterBusNumber_swigregister(IxxatAdapterBusNumber)
class Ixxat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ADAPTER_BUS_NUMBER_OPTIONS_NAME = property(_Nanolib.Ixxat_ADAPTER_BUS_NUMBER_OPTIONS_NAME_get)
    adapterBusNumber = property(_Nanolib.Ixxat_adapterBusNumber_get)

    def __init__(self):
        _Nanolib.Ixxat_swiginit(self, _Nanolib.new_Ixxat())
    __swig_destroy__ = _Nanolib.delete_Ixxat

# Register Ixxat in _Nanolib:
_Nanolib.Ixxat_swigregister(Ixxat)
class CanBus(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BAUD_RATE_OPTIONS_NAME = property(_Nanolib.CanBus_BAUD_RATE_OPTIONS_NAME_get)
    baudRate = property(_Nanolib.CanBus_baudRate_get)
    ixxat = property(_Nanolib.CanBus_ixxat_get)

    def __init__(self):
        _Nanolib.CanBus_swiginit(self, _Nanolib.new_CanBus())
    __swig_destroy__ = _Nanolib.delete_CanBus

# Register CanBus in _Nanolib:
_Nanolib.CanBus_swigregister(CanBus)
class SerialParity(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NONE = property(_Nanolib.SerialParity_NONE_get)
    ODD = property(_Nanolib.SerialParity_ODD_get)
    EVEN = property(_Nanolib.SerialParity_EVEN_get)
    MARK = property(_Nanolib.SerialParity_MARK_get)
    SPACE = property(_Nanolib.SerialParity_SPACE_get)

    def __init__(self):
        _Nanolib.SerialParity_swiginit(self, _Nanolib.new_SerialParity())
    __swig_destroy__ = _Nanolib.delete_SerialParity

# Register SerialParity in _Nanolib:
_Nanolib.SerialParity_swigregister(SerialParity)
class SerialBaudRate(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BAUD_RATE_7200 = property(_Nanolib.SerialBaudRate_BAUD_RATE_7200_get)
    BAUD_RATE_9600 = property(_Nanolib.SerialBaudRate_BAUD_RATE_9600_get)
    BAUD_RATE_14400 = property(_Nanolib.SerialBaudRate_BAUD_RATE_14400_get)
    BAUD_RATE_19200 = property(_Nanolib.SerialBaudRate_BAUD_RATE_19200_get)
    BAUD_RATE_38400 = property(_Nanolib.SerialBaudRate_BAUD_RATE_38400_get)
    BAUD_RATE_56000 = property(_Nanolib.SerialBaudRate_BAUD_RATE_56000_get)
    BAUD_RATE_57600 = property(_Nanolib.SerialBaudRate_BAUD_RATE_57600_get)
    BAUD_RATE_115200 = property(_Nanolib.SerialBaudRate_BAUD_RATE_115200_get)
    BAUD_RATE_128000 = property(_Nanolib.SerialBaudRate_BAUD_RATE_128000_get)
    BAUD_RATE_256000 = property(_Nanolib.SerialBaudRate_BAUD_RATE_256000_get)

    def __init__(self):
        _Nanolib.SerialBaudRate_swiginit(self, _Nanolib.new_SerialBaudRate())
    __swig_destroy__ = _Nanolib.delete_SerialBaudRate

# Register SerialBaudRate in _Nanolib:
_Nanolib.SerialBaudRate_swigregister(SerialBaudRate)
class Serial(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BAUD_RATE_OPTIONS_NAME = property(_Nanolib.Serial_BAUD_RATE_OPTIONS_NAME_get)
    baudRate = property(_Nanolib.Serial_baudRate_get)
    PARITY_OPTIONS_NAME = property(_Nanolib.Serial_PARITY_OPTIONS_NAME_get)
    parity = property(_Nanolib.Serial_parity_get)

    def __init__(self):
        _Nanolib.Serial_swiginit(self, _Nanolib.new_Serial())
    __swig_destroy__ = _Nanolib.delete_Serial

# Register Serial in _Nanolib:
_Nanolib.Serial_swigregister(Serial)
class RESTfulBus(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CONNECT_TIMEOUT_OPTION_NAME = property(_Nanolib.RESTfulBus_CONNECT_TIMEOUT_OPTION_NAME_get)
    DEFAULT_CONNECT_TIMEOUT = property(_Nanolib.RESTfulBus_DEFAULT_CONNECT_TIMEOUT_get)
    REQUEST_TIMEOUT_OPTION_NAME = property(_Nanolib.RESTfulBus_REQUEST_TIMEOUT_OPTION_NAME_get)
    DEFAULT_REQUEST_TIMEOUT = property(_Nanolib.RESTfulBus_DEFAULT_REQUEST_TIMEOUT_get)
    RESPONSE_TIMEOUT_OPTION_NAME = property(_Nanolib.RESTfulBus_RESPONSE_TIMEOUT_OPTION_NAME_get)
    DEFAULT_RESPONSE_TIMEOUT = property(_Nanolib.RESTfulBus_DEFAULT_RESPONSE_TIMEOUT_get)

    def __init__(self):
        _Nanolib.RESTfulBus_swiginit(self, _Nanolib.new_RESTfulBus())
    __swig_destroy__ = _Nanolib.delete_RESTfulBus

# Register RESTfulBus in _Nanolib:
_Nanolib.RESTfulBus_swigregister(RESTfulBus)
class EtherCATBus(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NETWORK_FIRMWARE_STATE_OPTION_NAME = property(_Nanolib.EtherCATBus_NETWORK_FIRMWARE_STATE_OPTION_NAME_get)
    DEFAULT_NETWORK_FIRMWARE_STATE = property(_Nanolib.EtherCATBus_DEFAULT_NETWORK_FIRMWARE_STATE_get)
    EXCLUSIVE_LOCK_TIMEOUT_OPTION_NAME = property(_Nanolib.EtherCATBus_EXCLUSIVE_LOCK_TIMEOUT_OPTION_NAME_get)
    DEFAULT_EXCLUSIVE_LOCK_TIMEOUT = property(_Nanolib.EtherCATBus_DEFAULT_EXCLUSIVE_LOCK_TIMEOUT_get)
    SHARED_LOCK_TIMEOUT_OPTION_NAME = property(_Nanolib.EtherCATBus_SHARED_LOCK_TIMEOUT_OPTION_NAME_get)
    DEFAULT_SHARED_LOCK_TIMEOUT = property(_Nanolib.EtherCATBus_DEFAULT_SHARED_LOCK_TIMEOUT_get)
    READ_TIMEOUT_OPTION_NAME = property(_Nanolib.EtherCATBus_READ_TIMEOUT_OPTION_NAME_get)
    DEFAULT_READ_TIMEOUT = property(_Nanolib.EtherCATBus_DEFAULT_READ_TIMEOUT_get)
    WRITE_TIMEOUT_OPTION_NAME = property(_Nanolib.EtherCATBus_WRITE_TIMEOUT_OPTION_NAME_get)
    DEFAULT_WRITE_TIMEOUT = property(_Nanolib.EtherCATBus_DEFAULT_WRITE_TIMEOUT_get)
    READ_WRITE_ATTEMPTS_OPTION_NAME = property(_Nanolib.EtherCATBus_READ_WRITE_ATTEMPTS_OPTION_NAME_get)
    DEFAULT_READ_WRITE_ATTEMPTS = property(_Nanolib.EtherCATBus_DEFAULT_READ_WRITE_ATTEMPTS_get)
    CHANGE_NETWORK_STATE_ATTEMPTS_OPTION_NAME = property(_Nanolib.EtherCATBus_CHANGE_NETWORK_STATE_ATTEMPTS_OPTION_NAME_get)
    DEFAULT_CHANGE_NETWORK_STATE_ATTEMPTS = property(_Nanolib.EtherCATBus_DEFAULT_CHANGE_NETWORK_STATE_ATTEMPTS_get)
    PDO_IO_ENABLED_OPTION_NAME = property(_Nanolib.EtherCATBus_PDO_IO_ENABLED_OPTION_NAME_get)
    DEFAULT_PDO_IO_ENABLED = property(_Nanolib.EtherCATBus_DEFAULT_PDO_IO_ENABLED_get)

    def __init__(self):
        _Nanolib.EtherCATBus_swiginit(self, _Nanolib.new_EtherCATBus())
    __swig_destroy__ = _Nanolib.delete_EtherCATBus

# Register EtherCATBus in _Nanolib:
_Nanolib.EtherCATBus_swigregister(EtherCATBus)
class BusHwOptionsDefault(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    canBus = property(_Nanolib.BusHwOptionsDefault_canBus_get)
    serial = property(_Nanolib.BusHwOptionsDefault_serial_get)
    restfulBus = property(_Nanolib.BusHwOptionsDefault_restfulBus_get)
    ethercatBus = property(_Nanolib.BusHwOptionsDefault_ethercatBus_get)

    def __init__(self):
        _Nanolib.BusHwOptionsDefault_swiginit(self, _Nanolib.new_BusHwOptionsDefault())
    __swig_destroy__ = _Nanolib.delete_BusHwOptionsDefault

# Register BusHwOptionsDefault in _Nanolib:
_Nanolib.BusHwOptionsDefault_swigregister(BusHwOptionsDefault)
class NanoLibAccessor(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__ = _Nanolib.delete_NanoLibAccessor

    def setLoggingLevel(self, level):
        return _Nanolib.NanoLibAccessor_setLoggingLevel(self, level)

    def setLoggingCallback(self, callback, level):
        return _Nanolib.NanoLibAccessor_setLoggingCallback(self, callback, level)

    def unsetLoggingCallback(self):
        return _Nanolib.NanoLibAccessor_unsetLoggingCallback(self)

    def listAvailableBusHardware(self):
        return _Nanolib.NanoLibAccessor_listAvailableBusHardware(self)

    def openBusHardwareWithProtocol(self, busHwId, busHwOpt):
        return _Nanolib.NanoLibAccessor_openBusHardwareWithProtocol(self, busHwId, busHwOpt)

    def closeBusHardware(self, busHwId):
        return _Nanolib.NanoLibAccessor_closeBusHardware(self, busHwId)

    def setBusState(self, busHwId, state):
        return _Nanolib.NanoLibAccessor_setBusState(self, busHwId, state)

    def addDevice(self, deviceId):
        return _Nanolib.NanoLibAccessor_addDevice(self, deviceId)

    def removeDevice(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_removeDevice(self, deviceHandle)

    def getDeviceId(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceId(self, deviceHandle)

    def getDeviceIds(self):
        return _Nanolib.NanoLibAccessor_getDeviceIds(self)

    def connectDevice(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_connectDevice(self, deviceHandle)

    def disconnectDevice(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_disconnectDevice(self, deviceHandle)

    def rebootDevice(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_rebootDevice(self, deviceHandle)

    def getDeviceVendorId(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceVendorId(self, deviceHandle)

    def getDeviceProductCode(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceProductCode(self, deviceHandle)

    def getDeviceName(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceName(self, deviceHandle)

    def getDeviceHardwareVersion(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceHardwareVersion(self, deviceHandle)

    def getDeviceFirmwareBuildId(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceFirmwareBuildId(self, deviceHandle)

    def getDeviceBootloaderBuildId(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceBootloaderBuildId(self, deviceHandle)

    def getDeviceSerialNumber(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceSerialNumber(self, deviceHandle)

    def getDeviceUid(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceUid(self, deviceHandle)

    def getDeviceBootloaderVersion(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceBootloaderVersion(self, deviceHandle)

    def getDeviceHardwareGroup(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceHardwareGroup(self, deviceHandle)

    def getConnectionState(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getConnectionState(self, deviceHandle)

    def checkConnectionState(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_checkConnectionState(self, deviceHandle)

    def getDeviceState(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getDeviceState(self, deviceHandle)

    def setDeviceState(self, deviceHandle, state):
        return _Nanolib.NanoLibAccessor_setDeviceState(self, deviceHandle, state)

    def scanDevices(self, busHwId, callback):
        return _Nanolib.NanoLibAccessor_scanDevices(self, busHwId, callback)

    def getProtocolSpecificAccessor(self, busHwId):
        return _Nanolib.NanoLibAccessor_getProtocolSpecificAccessor(self, busHwId)

    def isBusHardwareOpen(self, busHardwareId):
        return _Nanolib.NanoLibAccessor_isBusHardwareOpen(self, busHardwareId)

    def readNumber(self, deviceHandle, odIndex):
        return _Nanolib.NanoLibAccessor_readNumber(self, deviceHandle, odIndex)

    def readString(self, deviceHandle, odIndex):
        return _Nanolib.NanoLibAccessor_readString(self, deviceHandle, odIndex)

    def readBytes(self, deviceHandle, odIndex):
        return _Nanolib.NanoLibAccessor_readBytes(self, deviceHandle, odIndex)

    def writeNumber(self, deviceHandle, value, odIndex, bitLength):
        return _Nanolib.NanoLibAccessor_writeNumber(self, deviceHandle, value, odIndex, bitLength)

    def writeBytes(self, deviceHandle, data, odIndex):
        return _Nanolib.NanoLibAccessor_writeBytes(self, deviceHandle, data, odIndex)

    def readNumberArray(self, deviceHandle, index):
        return _Nanolib.NanoLibAccessor_readNumberArray(self, deviceHandle, index)

    def uploadFirmwareFromFile(self, deviceHandle, absoluteFilePath, callback):
        return _Nanolib.NanoLibAccessor_uploadFirmwareFromFile(self, deviceHandle, absoluteFilePath, callback)

    def uploadFirmware(self, deviceHandle, fwData, callback):
        return _Nanolib.NanoLibAccessor_uploadFirmware(self, deviceHandle, fwData, callback)

    def uploadBootloaderFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, callback):
        return _Nanolib.NanoLibAccessor_uploadBootloaderFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, callback)

    def uploadBootloader(self, deviceHandle, btData, callback):
        return _Nanolib.NanoLibAccessor_uploadBootloader(self, deviceHandle, btData, callback)

    def uploadBootloaderFirmwareFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, absoluteFilePath, callback):
        return _Nanolib.NanoLibAccessor_uploadBootloaderFirmwareFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, absoluteFilePath, callback)

    def uploadBootloaderFirmware(self, deviceHandle, btData, fwData, callback):
        return _Nanolib.NanoLibAccessor_uploadBootloaderFirmware(self, deviceHandle, btData, fwData, callback)

    def uploadNanoJFromFile(self, deviceHandle, absoluteFilePath, callback):
        return _Nanolib.NanoLibAccessor_uploadNanoJFromFile(self, deviceHandle, absoluteFilePath, callback)

    def uploadNanoJ(self, deviceHandle, vmmData, callback):
        return _Nanolib.NanoLibAccessor_uploadNanoJ(self, deviceHandle, vmmData, callback)

    def getObjectDictionaryLibrary(self):
        return _Nanolib.NanoLibAccessor_getObjectDictionaryLibrary(self)

    def assignObjectDictionary(self, deviceHandle, objectDictionary):
        return _Nanolib.NanoLibAccessor_assignObjectDictionary(self, deviceHandle, objectDictionary)

    def autoAssignObjectDictionary(self, deviceHandle, dictionariesLocationPath):
        return _Nanolib.NanoLibAccessor_autoAssignObjectDictionary(self, deviceHandle, dictionariesLocationPath)

    def getAssignedObjectDictionary(self, deviceHandle):
        return _Nanolib.NanoLibAccessor_getAssignedObjectDictionary(self, deviceHandle)

    def getProfinetDCP(self):
        return _Nanolib.NanoLibAccessor_getProfinetDCP(self)

    def getSamplerInterface(self):
        return _Nanolib.NanoLibAccessor_getSamplerInterface(self)

# Register NanoLibAccessor in _Nanolib:
_Nanolib.NanoLibAccessor_swigregister(NanoLibAccessor)
busHwOptionsDefaults = cvar.busHwOptionsDefaults


def getNanoLibAccessor():
    return _Nanolib.getNanoLibAccessor()

