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

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

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _nanolib_python
else:
    import _nanolib_python

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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_python.imaxdiv_t_quot_get, _nanolib_python.imaxdiv_t_quot_set)
    rem = property(_nanolib_python.imaxdiv_t_rem_get, _nanolib_python.imaxdiv_t_rem_set)

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

LogLevel_Off = _nanolib_python.LogLevel_Off
LogLevel_Trace = _nanolib_python.LogLevel_Trace
LogLevel_Debug = _nanolib_python.LogLevel_Debug
LogLevel_Info = _nanolib_python.LogLevel_Info
LogLevel_Warn = _nanolib_python.LogLevel_Warn
LogLevel_Error = _nanolib_python.LogLevel_Error
NlcErrorCode_Success = _nanolib_python.NlcErrorCode_Success
NlcErrorCode_GeneralError = _nanolib_python.NlcErrorCode_GeneralError
NlcErrorCode_IoError = _nanolib_python.NlcErrorCode_IoError
NlcErrorCode_CommunicationError = _nanolib_python.NlcErrorCode_CommunicationError
NlcErrorCode_TimeoutError = _nanolib_python.NlcErrorCode_TimeoutError
NlcErrorCode_NotConnected = _nanolib_python.NlcErrorCode_NotConnected
NlcErrorCode_InvalidArguments = _nanolib_python.NlcErrorCode_InvalidArguments
NlcErrorCode_ProtocolError = _nanolib_python.NlcErrorCode_ProtocolError
NlcErrorCode_InvalidOdAddress = _nanolib_python.NlcErrorCode_InvalidOdAddress
NlcErrorCode_InvalidOperation = _nanolib_python.NlcErrorCode_InvalidOperation
NlcErrorCode_AbortOperation = _nanolib_python.NlcErrorCode_AbortOperation
NlcErrorCode_ObjectDoesNotExist = _nanolib_python.NlcErrorCode_ObjectDoesNotExist
NlcErrorCode_DictionaryDoesNotExist = _nanolib_python.NlcErrorCode_DictionaryDoesNotExist
NlcErrorCode_TypeMismatch = _nanolib_python.NlcErrorCode_TypeMismatch
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_python.OdIndex_swiginit(self, _nanolib_python.new_OdIndex(*args))

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

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

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

# Register OdIndex in _nanolib_python:
_nanolib_python.OdIndex_swigregister(OdIndex)

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_python.delete_BusHardwareId

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

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

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

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

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

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

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

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

# Register BusHardwareId in _nanolib_python:
_nanolib_python.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_python.BusHardwareOptions_swiginit(self, _nanolib_python.new_BusHardwareOptions(*args))

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

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

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

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

# Register BusHardwareOptions in _nanolib_python:
_nanolib_python.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_python.DeviceId_swiginit(self, _nanolib_python.new_DeviceId(*args))

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

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

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

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

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

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

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

# Register DeviceId in _nanolib_python:
_nanolib_python.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_python.DeviceHandle_swiginit(self, _nanolib_python.new_DeviceHandle())
    __swig_destroy__ = _nanolib_python.delete_DeviceHandle

# Register DeviceHandle in _nanolib_python:
_nanolib_python.DeviceHandle_swigregister(DeviceHandle)

ObjectCode_Null = _nanolib_python.ObjectCode_Null
ObjectCode_Deftype = _nanolib_python.ObjectCode_Deftype
ObjectCode_Defstruct = _nanolib_python.ObjectCode_Defstruct
ObjectCode_Var = _nanolib_python.ObjectCode_Var
ObjectCode_Array = _nanolib_python.ObjectCode_Array
ObjectCode_Record = _nanolib_python.ObjectCode_Record
ObjectModificationAttribute_Constant = _nanolib_python.ObjectModificationAttribute_Constant
ObjectModificationAttribute_Variable = _nanolib_python.ObjectModificationAttribute_Variable
ObjectSdoAccessAttribute_ReadOnly = _nanolib_python.ObjectSdoAccessAttribute_ReadOnly
ObjectSdoAccessAttribute_WriteOnly = _nanolib_python.ObjectSdoAccessAttribute_WriteOnly
ObjectSdoAccessAttribute_ReadWrite = _nanolib_python.ObjectSdoAccessAttribute_ReadWrite
ObjectSdoAccessAttribute_NoAccess = _nanolib_python.ObjectSdoAccessAttribute_NoAccess
ObjectPdoAccessAttribute_Tx = _nanolib_python.ObjectPdoAccessAttribute_Tx
ObjectPdoAccessAttribute_Rx = _nanolib_python.ObjectPdoAccessAttribute_Rx
ObjectPdoAccessAttribute_TxRx = _nanolib_python.ObjectPdoAccessAttribute_TxRx
ObjectPdoAccessAttribute_No = _nanolib_python.ObjectPdoAccessAttribute_No
ObjectEntryDataType_Invalid = _nanolib_python.ObjectEntryDataType_Invalid
ObjectEntryDataType_Boolean = _nanolib_python.ObjectEntryDataType_Boolean
ObjectEntryDataType_Integer8 = _nanolib_python.ObjectEntryDataType_Integer8
ObjectEntryDataType_Integer16 = _nanolib_python.ObjectEntryDataType_Integer16
ObjectEntryDataType_Integer32 = _nanolib_python.ObjectEntryDataType_Integer32
ObjectEntryDataType_Unsigned8 = _nanolib_python.ObjectEntryDataType_Unsigned8
ObjectEntryDataType_Unsigned16 = _nanolib_python.ObjectEntryDataType_Unsigned16
ObjectEntryDataType_Unsigned32 = _nanolib_python.ObjectEntryDataType_Unsigned32
ObjectEntryDataType_Real32 = _nanolib_python.ObjectEntryDataType_Real32
ObjectEntryDataType_VisibleString = _nanolib_python.ObjectEntryDataType_VisibleString
ObjectEntryDataType_OctetString = _nanolib_python.ObjectEntryDataType_OctetString
ObjectEntryDataType_UnicodeString = _nanolib_python.ObjectEntryDataType_UnicodeString
ObjectEntryDataType_TimeOfDay = _nanolib_python.ObjectEntryDataType_TimeOfDay
ObjectEntryDataType_TimeDifference = _nanolib_python.ObjectEntryDataType_TimeDifference
ObjectEntryDataType_Domain = _nanolib_python.ObjectEntryDataType_Domain
ObjectEntryDataType_PdoCommunicationParameter = _nanolib_python.ObjectEntryDataType_PdoCommunicationParameter
ObjectEntryDataType_PdoMapping = _nanolib_python.ObjectEntryDataType_PdoMapping
ObjectEntryDataType_Identity = _nanolib_python.ObjectEntryDataType_Identity
ObjectEntryDataType_SyncmgrSynchronization = _nanolib_python.ObjectEntryDataType_SyncmgrSynchronization
ObjectEntryDataType_SamplerConfig = _nanolib_python.ObjectEntryDataType_SamplerConfig
ObjectEntryDataType_SamplerTimebase = _nanolib_python.ObjectEntryDataType_SamplerTimebase
ObjectEntryDataType_PdiInput = _nanolib_python.ObjectEntryDataType_PdiInput
ObjectEntryDataType_PdiOutput = _nanolib_python.ObjectEntryDataType_PdiOutput
ObjectEntryDataType_ClosedLoopControllerParameter = _nanolib_python.ObjectEntryDataType_ClosedLoopControllerParameter
ObjectEntryDataType_OpenLoopControllerParameter = _nanolib_python.ObjectEntryDataType_OpenLoopControllerParameter
ObjectEntryDataType_SsiEncoder = _nanolib_python.ObjectEntryDataType_SsiEncoder
ObjectEntryDataType_InterpolationTimePeriod = _nanolib_python.ObjectEntryDataType_InterpolationTimePeriod
ObjectEntryDataType_InterpolationDataConfiguration = _nanolib_python.ObjectEntryDataType_InterpolationDataConfiguration
ObjectEntryDataType_VelocityAccelerationDeceleration = _nanolib_python.ObjectEntryDataType_VelocityAccelerationDeceleration
ObjectEntryDataType_Simple = _nanolib_python.ObjectEntryDataType_Simple
ObjectEntryDataType_Complex = _nanolib_python.ObjectEntryDataType_Complex
ObjectEntryDataType_Unknown = _nanolib_python.ObjectEntryDataType_Unknown
ObjectSaveable_APPLICATION = _nanolib_python.ObjectSaveable_APPLICATION
ObjectSaveable_COMMUNICATION = _nanolib_python.ObjectSaveable_COMMUNICATION
ObjectSaveable_DRIVE = _nanolib_python.ObjectSaveable_DRIVE
ObjectSaveable_MISC_CONFIG = _nanolib_python.ObjectSaveable_MISC_CONFIG
ObjectSaveable_MODBUS_RTU = _nanolib_python.ObjectSaveable_MODBUS_RTU
ObjectSaveable_NO = _nanolib_python.ObjectSaveable_NO
ObjectSaveable_TUNING = _nanolib_python.ObjectSaveable_TUNING
ObjectSaveable_CUSTOMER = _nanolib_python.ObjectSaveable_CUSTOMER
ObjectSaveable_ETHERNET = _nanolib_python.ObjectSaveable_ETHERNET
ObjectSaveable_CANOPEN = _nanolib_python.ObjectSaveable_CANOPEN
ObjectSaveable_PROFIBUS = _nanolib_python.ObjectSaveable_PROFIBUS
ObjectSaveable_VERIFY1020 = _nanolib_python.ObjectSaveable_VERIFY1020
ObjectSaveable_UNKNOWN_SAVEABLE_TYPE = _nanolib_python.ObjectSaveable_UNKNOWN_SAVEABLE_TYPE
class NanotecException(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, msg, errCode, exErrCode):
        _nanolib_python.NanotecException_swiginit(self, _nanolib_python.new_NanotecException(msg, errCode, exErrCode))

    def what(self):
        return _nanolib_python.NanotecException_what(self)

    def getErrorCode(self):
        return _nanolib_python.NanotecException_getErrorCode(self)

    def getExErrorCode(self):
        return _nanolib_python.NanotecException_getExErrorCode(self)
    __swig_destroy__ = _nanolib_python.delete_NanotecException

# Register NanotecException in _nanolib_python:
_nanolib_python.NanotecException_swigregister(NanotecException)

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

    def __init__(self, message, abortCode):
        _nanolib_python.AbortException_swiginit(self, _nanolib_python.new_AbortException(message, abortCode))
    __swig_destroy__ = _nanolib_python.delete_AbortException

# Register AbortException in _nanolib_python:
_nanolib_python.AbortException_swigregister(AbortException)

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

    def __init__(self, message):
        _nanolib_python.InvalidAddressException_swiginit(self, _nanolib_python.new_InvalidAddressException(message))
    __swig_destroy__ = _nanolib_python.delete_InvalidAddressException

# Register InvalidAddressException in _nanolib_python:
_nanolib_python.InvalidAddressException_swigregister(InvalidAddressException)

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

    def __init__(self, message):
        _nanolib_python.ProtocolException_swiginit(self, _nanolib_python.new_ProtocolException(message))
    __swig_destroy__ = _nanolib_python.delete_ProtocolException

# Register ProtocolException in _nanolib_python:
_nanolib_python.ProtocolException_swigregister(ProtocolException)

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

    def __init__(self, message):
        _nanolib_python.ResourceException_swiginit(self, _nanolib_python.new_ResourceException(message))
    __swig_destroy__ = _nanolib_python.delete_ResourceException

# Register ResourceException in _nanolib_python:
_nanolib_python.ResourceException_swigregister(ResourceException)

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

    def __init__(self, message):
        _nanolib_python.TimeoutException_swiginit(self, _nanolib_python.new_TimeoutException(message))
    __swig_destroy__ = _nanolib_python.delete_TimeoutException

# Register TimeoutException in _nanolib_python:
_nanolib_python.TimeoutException_swigregister(TimeoutException)

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

    def __init__(self, message):
        _nanolib_python.InvalidArgumentException_swiginit(self, _nanolib_python.new_InvalidArgumentException(message))
    __swig_destroy__ = _nanolib_python.delete_InvalidArgumentException

# Register InvalidArgumentException in _nanolib_python:
_nanolib_python.InvalidArgumentException_swigregister(InvalidArgumentException)

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

    def __init__(self, message):
        _nanolib_python.LogicException_swiginit(self, _nanolib_python.new_LogicException(message))
    __swig_destroy__ = _nanolib_python.delete_LogicException

# Register LogicException in _nanolib_python:
_nanolib_python.LogicException_swigregister(LogicException)

DataTransferInfo_FileOpen = _nanolib_python.DataTransferInfo_FileOpen
DataTransferInfo_Init = _nanolib_python.DataTransferInfo_Init
DataTransferInfo_Progress = _nanolib_python.DataTransferInfo_Progress
DataTransferInfo_Reboot = _nanolib_python.DataTransferInfo_Reboot
DataTransferInfo_Finished = _nanolib_python.DataTransferInfo_Finished
BusScanInfo_Start = _nanolib_python.BusScanInfo_Start
BusScanInfo_Progress = _nanolib_python.BusScanInfo_Progress
BusScanInfo_FoundDevice = _nanolib_python.BusScanInfo_FoundDevice
BusScanInfo_Finished = _nanolib_python.BusScanInfo_Finished
DeviceConnectionStateInfo_Disconnected = _nanolib_python.DeviceConnectionStateInfo_Disconnected
DeviceConnectionStateInfo_Connected = _nanolib_python.DeviceConnectionStateInfo_Connected
DeviceConnectionStateInfo_ConnectedBootloader = _nanolib_python.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_python.CanOpenNmtState_STOPPED_get)
    PRE_OPERATIONAL = property(_nanolib_python.CanOpenNmtState_PRE_OPERATIONAL_get)
    OPERATIONAL = property(_nanolib_python.CanOpenNmtState_OPERATIONAL_get)
    INITIALIZATION = property(_nanolib_python.CanOpenNmtState_INITIALIZATION_get)
    UNKNOWN = property(_nanolib_python.CanOpenNmtState_UNKNOWN_get)

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

# Register CanOpenNmtState in _nanolib_python:
_nanolib_python.CanOpenNmtState_swigregister(CanOpenNmtState)
cvar = _nanolib_python.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_python.CanOpenNmtService_START_get)
    STOP = property(_nanolib_python.CanOpenNmtService_STOP_get)
    PRE_OPERATIONAL = property(_nanolib_python.CanOpenNmtService_PRE_OPERATIONAL_get)
    RESET = property(_nanolib_python.CanOpenNmtService_RESET_get)
    RESET_COMMUNICATION = property(_nanolib_python.CanOpenNmtService_RESET_COMMUNICATION_get)

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

# Register CanOpenNmtService in _nanolib_python:
_nanolib_python.CanOpenNmtService_swigregister(CanOpenNmtService)

class Result(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_python.Result_swiginit(self, _nanolib_python.new_Result(*args))
    __swig_destroy__ = _nanolib_python.delete_Result

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

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

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

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

# Register Result in _nanolib_python:
_nanolib_python.Result_swigregister(Result)
canOpenNmtState = cvar.canOpenNmtState
canOpenNmtService = cvar.canOpenNmtService

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_python.ResultVoid_swiginit(self, _nanolib_python.new_ResultVoid(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultVoid

# Register ResultVoid in _nanolib_python:
_nanolib_python.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_python.ResultInt_swiginit(self, _nanolib_python.new_ResultInt(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultInt

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

# Register ResultInt in _nanolib_python:
_nanolib_python.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_python.ResultString_swiginit(self, _nanolib_python.new_ResultString(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultString

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

# Register ResultString in _nanolib_python:
_nanolib_python.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_python.ResultArrayInt_swiginit(self, _nanolib_python.new_ResultArrayInt(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultArrayInt

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

# Register ResultArrayInt in _nanolib_python:
_nanolib_python.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_python.ResultArrayByte_swiginit(self, _nanolib_python.new_ResultArrayByte(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultArrayByte

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

# Register ResultArrayByte in _nanolib_python:
_nanolib_python.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_python.ResultBusHwIds_swiginit(self, _nanolib_python.new_ResultBusHwIds(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultBusHwIds

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

# Register ResultBusHwIds in _nanolib_python:
_nanolib_python.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_python.ResultDeviceId_swiginit(self, _nanolib_python.new_ResultDeviceId(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultDeviceId

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

# Register ResultDeviceId in _nanolib_python:
_nanolib_python.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_python.ResultDeviceIds_swiginit(self, _nanolib_python.new_ResultDeviceIds(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultDeviceIds

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

# Register ResultDeviceIds in _nanolib_python:
_nanolib_python.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_python.ResultDeviceHandle_swiginit(self, _nanolib_python.new_ResultDeviceHandle(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultDeviceHandle

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

# Register ResultDeviceHandle in _nanolib_python:
_nanolib_python.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_python.ResultConnectionState_swiginit(self, _nanolib_python.new_ResultConnectionState(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultConnectionState

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

# Register ResultConnectionState in _nanolib_python:
_nanolib_python.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_python.ResultObjectEntry_swiginit(self, _nanolib_python.new_ResultObjectEntry(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultObjectEntry

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

# Register ResultObjectEntry in _nanolib_python:
_nanolib_python.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_python.ResultObjectSubEntry_swiginit(self, _nanolib_python.new_ResultObjectSubEntry(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultObjectSubEntry

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

# Register ResultObjectSubEntry in _nanolib_python:
_nanolib_python.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_python.ResultObjectDictionary_swiginit(self, _nanolib_python.new_ResultObjectDictionary(*args))
    __swig_destroy__ = _nanolib_python.delete_ResultObjectDictionary

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

# Register ResultObjectDictionary in _nanolib_python:
_nanolib_python.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_python.delete_NlcCallback

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

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

# Register NlcCallback in _nanolib_python:
_nanolib_python.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_python.delete_NlcDataTransferCallback

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

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

# Register NlcDataTransferCallback in _nanolib_python:
_nanolib_python.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_python.delete_NlcScanBusCallback

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

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

# Register NlcScanBusCallback in _nanolib_python:
_nanolib_python.NlcScanBusCallback_swigregister(NlcScanBusCallback)

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_python.delete_OdLibrary

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

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

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

    def addObjectDictionary(self, odXmlData):
        return _nanolib_python.OdLibrary_addObjectDictionary(self, odXmlData)

# Register OdLibrary in _nanolib_python:
_nanolib_python.OdLibrary_swigregister(OdLibrary)

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_python.ObjectDictionary_swiginit(self, _nanolib_python.new_ObjectDictionary())
    __swig_destroy__ = _nanolib_python.delete_ObjectDictionary

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

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

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

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

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

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

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

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

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

# Register ObjectDictionary in _nanolib_python:
_nanolib_python.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_python.ObjectEntry_swiginit(self, _nanolib_python.new_ObjectEntry())
    __swig_destroy__ = _nanolib_python.delete_ObjectEntry

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

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

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

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

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

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

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

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

# Register ObjectEntry in _nanolib_python:
_nanolib_python.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_python.ObjectSubEntry_swiginit(self, _nanolib_python.new_ObjectSubEntry())
    __swig_destroy__ = _nanolib_python.delete_ObjectSubEntry

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register ObjectSubEntry in _nanolib_python:
_nanolib_python.ObjectSubEntry_swigregister(ObjectSubEntry)

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_python.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register IntVector in _nanolib_python:
_nanolib_python.IntVector_swigregister(IntVector)
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_NANOTEC_VCP = cvar.BUS_HARDWARE_ID_NANOTEC_VCP
BUS_HARDWARE_ID_USB_HUB = cvar.BUS_HARDWARE_ID_USB_HUB
BUS_HARDWARE_ID_PROTOCOL_MODBUS_TCP = cvar.BUS_HARDWARE_ID_PROTOCOL_MODBUS_TCP
BUS_HARDWARE_ID_NETWORK = cvar.BUS_HARDWARE_ID_NETWORK

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_python.ByteVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register ByteVector in _nanolib_python:
_nanolib_python.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_python.BusHWIdVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register BusHWIdVector in _nanolib_python:
_nanolib_python.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_python.DeviceIdVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register DeviceIdVector in _nanolib_python:
_nanolib_python.DeviceIdVector_swigregister(DeviceIdVector)

class String_Int_Map(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_python.String_Int_Map_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _nanolib_python.String_Int_Map___nonzero__(self)

    def __bool__(self):
        return _nanolib_python.String_Int_Map___bool__(self)

    def __len__(self):
        return _nanolib_python.String_Int_Map___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_python.String_Int_Map___getitem__(self, key)

    def __delitem__(self, key):
        return _nanolib_python.String_Int_Map___delitem__(self, key)

    def has_key(self, key):
        return _nanolib_python.String_Int_Map_has_key(self, key)

    def keys(self):
        return _nanolib_python.String_Int_Map_keys(self)

    def values(self):
        return _nanolib_python.String_Int_Map_values(self)

    def items(self):
        return _nanolib_python.String_Int_Map_items(self)

    def __contains__(self, key):
        return _nanolib_python.String_Int_Map___contains__(self, key)

    def key_iterator(self):
        return _nanolib_python.String_Int_Map_key_iterator(self)

    def value_iterator(self):
        return _nanolib_python.String_Int_Map_value_iterator(self)

    def __setitem__(self, *args):
        return _nanolib_python.String_Int_Map___setitem__(self, *args)

    def asdict(self):
        return _nanolib_python.String_Int_Map_asdict(self)

    def __init__(self, *args):
        _nanolib_python.String_Int_Map_swiginit(self, _nanolib_python.new_String_Int_Map(*args))

    def empty(self):
        return _nanolib_python.String_Int_Map_empty(self)

    def size(self):
        return _nanolib_python.String_Int_Map_size(self)

    def swap(self, v):
        return _nanolib_python.String_Int_Map_swap(self, v)

    def begin(self):
        return _nanolib_python.String_Int_Map_begin(self)

    def end(self):
        return _nanolib_python.String_Int_Map_end(self)

    def rbegin(self):
        return _nanolib_python.String_Int_Map_rbegin(self)

    def rend(self):
        return _nanolib_python.String_Int_Map_rend(self)

    def clear(self):
        return _nanolib_python.String_Int_Map_clear(self)

    def get_allocator(self):
        return _nanolib_python.String_Int_Map_get_allocator(self)

    def count(self, x):
        return _nanolib_python.String_Int_Map_count(self, x)

    def erase(self, *args):
        return _nanolib_python.String_Int_Map_erase(self, *args)

    def find(self, x):
        return _nanolib_python.String_Int_Map_find(self, x)

    def lower_bound(self, x):
        return _nanolib_python.String_Int_Map_lower_bound(self, x)

    def upper_bound(self, x):
        return _nanolib_python.String_Int_Map_upper_bound(self, x)
    __swig_destroy__ = _nanolib_python.delete_String_Int_Map

# Register String_Int_Map in _nanolib_python:
_nanolib_python.String_Int_Map_swigregister(String_Int_Map)

class String_String_Map(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_python.String_String_Map_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _nanolib_python.String_String_Map___nonzero__(self)

    def __bool__(self):
        return _nanolib_python.String_String_Map___bool__(self)

    def __len__(self):
        return _nanolib_python.String_String_Map___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_python.String_String_Map___getitem__(self, key)

    def __delitem__(self, key):
        return _nanolib_python.String_String_Map___delitem__(self, key)

    def has_key(self, key):
        return _nanolib_python.String_String_Map_has_key(self, key)

    def keys(self):
        return _nanolib_python.String_String_Map_keys(self)

    def values(self):
        return _nanolib_python.String_String_Map_values(self)

    def items(self):
        return _nanolib_python.String_String_Map_items(self)

    def __contains__(self, key):
        return _nanolib_python.String_String_Map___contains__(self, key)

    def key_iterator(self):
        return _nanolib_python.String_String_Map_key_iterator(self)

    def value_iterator(self):
        return _nanolib_python.String_String_Map_value_iterator(self)

    def __setitem__(self, *args):
        return _nanolib_python.String_String_Map___setitem__(self, *args)

    def asdict(self):
        return _nanolib_python.String_String_Map_asdict(self)

    def __init__(self, *args):
        _nanolib_python.String_String_Map_swiginit(self, _nanolib_python.new_String_String_Map(*args))

    def empty(self):
        return _nanolib_python.String_String_Map_empty(self)

    def size(self):
        return _nanolib_python.String_String_Map_size(self)

    def swap(self, v):
        return _nanolib_python.String_String_Map_swap(self, v)

    def begin(self):
        return _nanolib_python.String_String_Map_begin(self)

    def end(self):
        return _nanolib_python.String_String_Map_end(self)

    def rbegin(self):
        return _nanolib_python.String_String_Map_rbegin(self)

    def rend(self):
        return _nanolib_python.String_String_Map_rend(self)

    def clear(self):
        return _nanolib_python.String_String_Map_clear(self)

    def get_allocator(self):
        return _nanolib_python.String_String_Map_get_allocator(self)

    def count(self, x):
        return _nanolib_python.String_String_Map_count(self, x)

    def erase(self, *args):
        return _nanolib_python.String_String_Map_erase(self, *args)

    def find(self, x):
        return _nanolib_python.String_String_Map_find(self, x)

    def lower_bound(self, x):
        return _nanolib_python.String_String_Map_lower_bound(self, x)

    def upper_bound(self, x):
        return _nanolib_python.String_String_Map_upper_bound(self, x)
    __swig_destroy__ = _nanolib_python.delete_String_String_Map

# Register String_String_Map in _nanolib_python:
_nanolib_python.String_String_Map_swigregister(String_String_Map)

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_python.CanBaudRate_BAUD_RATE_1000K_get)
    BAUD_RATE_800K = property(_nanolib_python.CanBaudRate_BAUD_RATE_800K_get)
    BAUD_RATE_500K = property(_nanolib_python.CanBaudRate_BAUD_RATE_500K_get)
    BAUD_RATE_250K = property(_nanolib_python.CanBaudRate_BAUD_RATE_250K_get)
    BAUD_RATE_125K = property(_nanolib_python.CanBaudRate_BAUD_RATE_125K_get)
    BAUD_RATE_100K = property(_nanolib_python.CanBaudRate_BAUD_RATE_100K_get)
    BAUD_RATE_50K = property(_nanolib_python.CanBaudRate_BAUD_RATE_50K_get)
    BAUD_RATE_20K = property(_nanolib_python.CanBaudRate_BAUD_RATE_20K_get)
    BAUD_RATE_10K = property(_nanolib_python.CanBaudRate_BAUD_RATE_10K_get)
    BAUD_RATE_5K = property(_nanolib_python.CanBaudRate_BAUD_RATE_5K_get)

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

# Register CanBaudRate in _nanolib_python:
_nanolib_python.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_python.IxxatAdapterBusNumber_BUS_NUMBER_0_DEFAULT_get)
    BUS_NUMBER_1 = property(_nanolib_python.IxxatAdapterBusNumber_BUS_NUMBER_1_get)
    BUS_NUMBER_2 = property(_nanolib_python.IxxatAdapterBusNumber_BUS_NUMBER_2_get)
    BUS_NUMBER_3 = property(_nanolib_python.IxxatAdapterBusNumber_BUS_NUMBER_3_get)

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

# Register IxxatAdapterBusNumber in _nanolib_python:
_nanolib_python.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_python.Ixxat_ADAPTER_BUS_NUMBER_OPTIONS_NAME_get)
    adapterBusNumber = property(_nanolib_python.Ixxat_adapterBusNumber_get)

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

# Register Ixxat in _nanolib_python:
_nanolib_python.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_python.CanBus_BAUD_RATE_OPTIONS_NAME_get)
    baudRate = property(_nanolib_python.CanBus_baudRate_get)
    ixxat = property(_nanolib_python.CanBus_ixxat_get)

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

# Register CanBus in _nanolib_python:
_nanolib_python.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_python.SerialParity_NONE_get)
    ODD = property(_nanolib_python.SerialParity_ODD_get)
    EVEN = property(_nanolib_python.SerialParity_EVEN_get)
    MARK = property(_nanolib_python.SerialParity_MARK_get)
    SPACE = property(_nanolib_python.SerialParity_SPACE_get)

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

# Register SerialParity in _nanolib_python:
_nanolib_python.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_python.SerialBaudRate_BAUD_RATE_7200_get)
    BAUD_RATE_9600 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_9600_get)
    BAUD_RATE_14400 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_14400_get)
    BAUD_RATE_19200 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_19200_get)
    BAUD_RATE_38400 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_38400_get)
    BAUD_RATE_56000 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_56000_get)
    BAUD_RATE_57600 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_57600_get)
    BAUD_RATE_115200 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_115200_get)
    BAUD_RATE_128000 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_128000_get)
    BAUD_RATE_256000 = property(_nanolib_python.SerialBaudRate_BAUD_RATE_256000_get)

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

# Register SerialBaudRate in _nanolib_python:
_nanolib_python.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_python.Serial_BAUD_RATE_OPTIONS_NAME_get)
    baudRate = property(_nanolib_python.Serial_baudRate_get)
    PARITY_OPTIONS_NAME = property(_nanolib_python.Serial_PARITY_OPTIONS_NAME_get)
    parity = property(_nanolib_python.Serial_parity_get)

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

# Register Serial in _nanolib_python:
_nanolib_python.Serial_swigregister(Serial)

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_python.BusHwOptionsDefault_canBus_get)
    serial = property(_nanolib_python.BusHwOptionsDefault_serial_get)

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

# Register BusHwOptionsDefault in _nanolib_python:
_nanolib_python.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_python.delete_NanoLibAccessor

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def firmwareUploadFromFile(self, deviceHandle, absoluteFilePath, callback):
        return _nanolib_python.NanoLibAccessor_firmwareUploadFromFile(self, deviceHandle, absoluteFilePath, callback)

    def firmwareUpload(self, deviceHandle, fwData, callback):
        return _nanolib_python.NanoLibAccessor_firmwareUpload(self, deviceHandle, fwData, callback)

    def bootloaderUploadFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, callback):
        return _nanolib_python.NanoLibAccessor_bootloaderUploadFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, callback)

    def bootloaderUpload(self, deviceHandle, btData, callback):
        return _nanolib_python.NanoLibAccessor_bootloaderUpload(self, deviceHandle, btData, callback)

    def bootloaderFirmwareUploadFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, absoluteFilePath, callback):
        return _nanolib_python.NanoLibAccessor_bootloaderFirmwareUploadFromFile(self, deviceHandle, bootloaderAbsoluteFilePath, absoluteFilePath, callback)

    def bootloaderFirmwareUpload(self, deviceHandle, btData, fwData, callback):
        return _nanolib_python.NanoLibAccessor_bootloaderFirmwareUpload(self, deviceHandle, btData, fwData, callback)

    def nanojUploadFromFile(self, deviceHandle, absoluteFilePath, callback):
        return _nanolib_python.NanoLibAccessor_nanojUploadFromFile(self, deviceHandle, absoluteFilePath, callback)

    def nanojUpload(self, deviceHandle, vmmData, callback):
        return _nanolib_python.NanoLibAccessor_nanojUpload(self, deviceHandle, vmmData, callback)

    def objectDictionaryLibrary(self):
        return _nanolib_python.NanoLibAccessor_objectDictionaryLibrary(self)

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

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

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

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


def getNanoLibAccessor():
    return _nanolib_python.getNanoLibAccessor()


