# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.6
#
# 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
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_mscl', [dirname(__file__)])
        except ImportError:
            import _mscl
            return _mscl
        if fp is not None:
            try:
                _mod = imp.load_module('_mscl', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _mscl = swig_import_helper()
    del swig_import_helper
else:
    import _mscl
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class SwigPyIterator(object):
    thisown = _swig_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__ = _mscl.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _mscl.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _mscl.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _mscl.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _mscl.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _mscl.SwigPyIterator_equal(self, x)

    def copy(self):
        return _mscl.SwigPyIterator_copy(self)

    def next(self):
        return _mscl.SwigPyIterator_next(self)

    def __next__(self):
        return _mscl.SwigPyIterator___next__(self)

    def previous(self):
        return _mscl.SwigPyIterator_previous(self)

    def advance(self, n):
        return _mscl.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _mscl.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _mscl.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _mscl.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _mscl.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _mscl.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _mscl.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _mscl.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


_mscl.SHARED_PTR_DISOWN_swigconstant(_mscl)
SHARED_PTR_DISOWN = _mscl.SHARED_PTR_DISOWN

_mscl.valueType_float_swigconstant(_mscl)
valueType_float = _mscl.valueType_float

_mscl.valueType_double_swigconstant(_mscl)
valueType_double = _mscl.valueType_double

_mscl.valueType_uint8_swigconstant(_mscl)
valueType_uint8 = _mscl.valueType_uint8

_mscl.valueType_uint16_swigconstant(_mscl)
valueType_uint16 = _mscl.valueType_uint16

_mscl.valueType_uint32_swigconstant(_mscl)
valueType_uint32 = _mscl.valueType_uint32

_mscl.valueType_int16_swigconstant(_mscl)
valueType_int16 = _mscl.valueType_int16

_mscl.valueType_int32_swigconstant(_mscl)
valueType_int32 = _mscl.valueType_int32

_mscl.valueType_bool_swigconstant(_mscl)
valueType_bool = _mscl.valueType_bool

_mscl.valueType_Vector_swigconstant(_mscl)
valueType_Vector = _mscl.valueType_Vector

_mscl.valueType_Matrix_swigconstant(_mscl)
valueType_Matrix = _mscl.valueType_Matrix

_mscl.valueType_Timestamp_swigconstant(_mscl)
valueType_Timestamp = _mscl.valueType_Timestamp

_mscl.valueType_string_swigconstant(_mscl)
valueType_string = _mscl.valueType_string

_mscl.valueType_Bytes_swigconstant(_mscl)
valueType_Bytes = _mscl.valueType_Bytes

_mscl.valueType_StructuralHealth_swigconstant(_mscl)
valueType_StructuralHealth = _mscl.valueType_StructuralHealth

_mscl.valueType_RfSweep_swigconstant(_mscl)
valueType_RfSweep = _mscl.valueType_RfSweep

_mscl.valueType_ChannelMask_swigconstant(_mscl)
valueType_ChannelMask = _mscl.valueType_ChannelMask
class BitMask(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_BitMask(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_BitMask
    __del__ = lambda self: None

    def __eq__(self, other):
        return _mscl.BitMask___eq__(self, other)

    def __ne__(self, other):
        return _mscl.BitMask___ne__(self, other)

    def __lt__(self, other):
        return _mscl.BitMask___lt__(self, other)

    def __gt__(self, other):
        return _mscl.BitMask___gt__(self, other)

    def fromMask(self, val):
        return _mscl.BitMask_fromMask(self, val)

    def toMask(self):
        return _mscl.BitMask_toMask(self)

    def enabledCount(self):
        return _mscl.BitMask_enabledCount(self)

    def enabled(self, bitIndex):
        return _mscl.BitMask_enabled(self, bitIndex)

    def enable(self, bitIndex, enable=True):
        return _mscl.BitMask_enable(self, bitIndex, enable)

    def lastBitEnabled(self):
        return _mscl.BitMask_lastBitEnabled(self)
BitMask_swigregister = _mscl.BitMask_swigregister
BitMask_swigregister(BitMask)

class ChannelMask(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MAX_CHANNELS = _mscl.ChannelMask_MAX_CHANNELS

    def __init__(self, *args):
        this = _mscl.new_ChannelMask(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_ChannelMask
    __del__ = lambda self: None

    def __eq__(self, other):
        return _mscl.ChannelMask___eq__(self, other)

    def __ne__(self, other):
        return _mscl.ChannelMask___ne__(self, other)

    def __lt__(self, other):
        return _mscl.ChannelMask___lt__(self, other)

    def __gt__(self, other):
        return _mscl.ChannelMask___gt__(self, other)

    def fromMask(self, channelMask):
        return _mscl.ChannelMask_fromMask(self, channelMask)

    def toMask(self):
        return _mscl.ChannelMask_toMask(self)

    def count(self):
        return _mscl.ChannelMask_count(self)

    def enabled(self, channel):
        return _mscl.ChannelMask_enabled(self, channel)

    def enable(self, channel, enable=True):
        return _mscl.ChannelMask_enable(self, channel, enable)

    def lastChEnabled(self):
        return _mscl.ChannelMask_lastChEnabled(self)
ChannelMask_swigregister = _mscl.ChannelMask_swigregister
ChannelMask_swigregister(ChannelMask)

class Value(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mscl.delete_Value
    __del__ = lambda self: None

    def storedAs(self):
        return _mscl.Value_storedAs(self)

    def as_float(self):
        return _mscl.Value_as_float(self)

    def as_double(self):
        return _mscl.Value_as_double(self)

    def as_uint8(self):
        return _mscl.Value_as_uint8(self)

    def as_uint16(self):
        return _mscl.Value_as_uint16(self)

    def as_uint32(self):
        return _mscl.Value_as_uint32(self)

    def as_int16(self):
        return _mscl.Value_as_int16(self)

    def as_int32(self):
        return _mscl.Value_as_int32(self)

    def as_bool(self):
        return _mscl.Value_as_bool(self)

    def as_ChannelMask(self):
        return _mscl.Value_as_ChannelMask(self)

    def as_string(self):
        return _mscl.Value_as_string(self)
Value_swigregister = _mscl.Value_swigregister
Value_swigregister(Value)

class Bin(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, start, end, count):
        this = _mscl.new_Bin(start, end, count)
        try:
            self.this.append(this)
        except:
            self.this = this

    def start(self):
        return _mscl.Bin_start(self)

    def end(self):
        return _mscl.Bin_end(self)

    def count(self):
        return _mscl.Bin_count(self)
    __swig_destroy__ = _mscl.delete_Bin
    __del__ = lambda self: None
Bin_swigregister = _mscl.Bin_swigregister
Bin_swigregister(Bin)

class Histogram(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, binsStart, binsSize):
        this = _mscl.new_Histogram(binsStart, binsSize)
        try:
            self.this.append(this)
        except:
            self.this = this

    def binsStart(self):
        return _mscl.Histogram_binsStart(self)

    def binsSize(self):
        return _mscl.Histogram_binsSize(self)

    def bins(self):
        return _mscl.Histogram_bins(self)

    def addBin(self, bin):
        return _mscl.Histogram_addBin(self, bin)
    __swig_destroy__ = _mscl.delete_Histogram
    __del__ = lambda self: None
Histogram_swigregister = _mscl.Histogram_swigregister
Histogram_swigregister(Histogram)

class Timestamp(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Timestamp(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Timestamp
    __del__ = lambda self: None

    def nanoseconds(self):
        return _mscl.Timestamp_nanoseconds(self)

    def seconds(self):
        return _mscl.Timestamp_seconds(self)

    def __str__(self):
        return _mscl.Timestamp___str__(self)

    def setTime(self, nanosSinceEpoch):
        return _mscl.Timestamp_setTime(self, nanosSinceEpoch)

    def setTimeNow(self):
        return _mscl.Timestamp_setTimeNow(self)
    timeNow = staticmethod(_mscl.Timestamp_timeNow)
Timestamp_swigregister = _mscl.Timestamp_swigregister
Timestamp_swigregister(Timestamp)

def Timestamp_timeNow():
    return _mscl.Timestamp_timeNow()
Timestamp_timeNow = _mscl.Timestamp_timeNow

class TimeSpan(object):
    thisown = _swig_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
    NANOSECONDS_PER_MICROSECOND = _mscl.TimeSpan_NANOSECONDS_PER_MICROSECOND
    NANOSECONDS_PER_MILLISECOND = _mscl.TimeSpan_NANOSECONDS_PER_MILLISECOND
    NANOSECONDS_PER_SECOND = _mscl.TimeSpan_NANOSECONDS_PER_SECOND

    def getNanoseconds(self):
        return _mscl.TimeSpan_getNanoseconds(self)

    def getMicroseconds(self):
        return _mscl.TimeSpan_getMicroseconds(self)

    def getMilliseconds(self):
        return _mscl.TimeSpan_getMilliseconds(self)

    def getSeconds(self):
        return _mscl.TimeSpan_getSeconds(self)
    NanoSeconds = staticmethod(_mscl.TimeSpan_NanoSeconds)
    MicroSeconds = staticmethod(_mscl.TimeSpan_MicroSeconds)
    MilliSeconds = staticmethod(_mscl.TimeSpan_MilliSeconds)
    Seconds = staticmethod(_mscl.TimeSpan_Seconds)
    Minutes = staticmethod(_mscl.TimeSpan_Minutes)
    Hours = staticmethod(_mscl.TimeSpan_Hours)
    Days = staticmethod(_mscl.TimeSpan_Days)
    __swig_destroy__ = _mscl.delete_TimeSpan
    __del__ = lambda self: None
TimeSpan_swigregister = _mscl.TimeSpan_swigregister
TimeSpan_swigregister(TimeSpan)

def TimeSpan_NanoSeconds(nanoseconds):
    return _mscl.TimeSpan_NanoSeconds(nanoseconds)
TimeSpan_NanoSeconds = _mscl.TimeSpan_NanoSeconds

def TimeSpan_MicroSeconds(microseconds):
    return _mscl.TimeSpan_MicroSeconds(microseconds)
TimeSpan_MicroSeconds = _mscl.TimeSpan_MicroSeconds

def TimeSpan_MilliSeconds(milliseconds):
    return _mscl.TimeSpan_MilliSeconds(milliseconds)
TimeSpan_MilliSeconds = _mscl.TimeSpan_MilliSeconds

def TimeSpan_Seconds(seconds):
    return _mscl.TimeSpan_Seconds(seconds)
TimeSpan_Seconds = _mscl.TimeSpan_Seconds

def TimeSpan_Minutes(minutes):
    return _mscl.TimeSpan_Minutes(minutes)
TimeSpan_Minutes = _mscl.TimeSpan_Minutes

def TimeSpan_Hours(hours):
    return _mscl.TimeSpan_Hours(hours)
TimeSpan_Hours = _mscl.TimeSpan_Hours

def TimeSpan_Days(days):
    return _mscl.TimeSpan_Days(days)
TimeSpan_Days = _mscl.TimeSpan_Days

class Version(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Version(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __eq__(self, cmp):
        return _mscl.Version___eq__(self, cmp)

    def __ne__(self, cmp):
        return _mscl.Version___ne__(self, cmp)

    def __lt__(self, cmp):
        return _mscl.Version___lt__(self, cmp)

    def __le__(self, cmp):
        return _mscl.Version___le__(self, cmp)

    def __gt__(self, cmp):
        return _mscl.Version___gt__(self, cmp)

    def __ge__(self, cmp):
        return _mscl.Version___ge__(self, cmp)

    def __str__(self):
        return _mscl.Version___str__(self)

    def fromString(self, strVersion):
        return _mscl.Version_fromString(self, strVersion)

    def majorPart(self):
        return _mscl.Version_majorPart(self)

    def minorPart(self):
        return _mscl.Version_minorPart(self)

    def patchPart(self):
        return _mscl.Version_patchPart(self)
    __swig_destroy__ = _mscl.delete_Version
    __del__ = lambda self: None
Version_swigregister = _mscl.Version_swigregister
Version_swigregister(Version)

class DeviceInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    connectionType_serial = _mscl.DeviceInfo_connectionType_serial
    connectionType_tcp = _mscl.DeviceInfo_connectionType_tcp

    def __init__(self, *args):
        this = _mscl.new_DeviceInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def description(self):
        return _mscl.DeviceInfo_description(self)

    def serial(self):
        return _mscl.DeviceInfo_serial(self)

    def baudRate(self):
        return _mscl.DeviceInfo_baudRate(self)

    def connectionType(self):
        return _mscl.DeviceInfo_connectionType(self)
    __swig_destroy__ = _mscl.delete_DeviceInfo
    __del__ = lambda self: None
DeviceInfo_swigregister = _mscl.DeviceInfo_swigregister
DeviceInfo_swigregister(DeviceInfo)
cvar = _mscl.cvar
MSCL_VERSION = cvar.MSCL_VERSION

class Devices(object):
    thisown = _swig_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
    listBaseStations = staticmethod(_mscl.Devices_listBaseStations)
    listInertialDevices = staticmethod(_mscl.Devices_listInertialDevices)
    listPorts = staticmethod(_mscl.Devices_listPorts)
    __swig_destroy__ = _mscl.delete_Devices
    __del__ = lambda self: None
Devices_swigregister = _mscl.Devices_swigregister
Devices_swigregister(Devices)

def Devices_listBaseStations():
    return _mscl.Devices_listBaseStations()
Devices_listBaseStations = _mscl.Devices_listBaseStations

def Devices_listInertialDevices():
    return _mscl.Devices_listInertialDevices()
Devices_listInertialDevices = _mscl.Devices_listInertialDevices

def Devices_listPorts():
    return _mscl.Devices_listPorts()
Devices_listPorts = _mscl.Devices_listPorts

class ConnectionDebugData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_ConnectionDebugData(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def fromRead(self):
        return _mscl.ConnectionDebugData_fromRead(self)

    def timestamp(self):
        return _mscl.ConnectionDebugData_timestamp(self)

    def data(self):
        return _mscl.ConnectionDebugData_data(self)
    __swig_destroy__ = _mscl.delete_ConnectionDebugData
    __del__ = lambda self: None
ConnectionDebugData_swigregister = _mscl.ConnectionDebugData_swigregister
ConnectionDebugData_swigregister(ConnectionDebugData)

class Connection(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    connectionType_serial = _mscl.Connection_connectionType_serial
    connectionType_tcp = _mscl.Connection_connectionType_tcp
    connectionType_webSocket = _mscl.Connection_connectionType_webSocket
    connectionType_unixSocket = _mscl.Connection_connectionType_unixSocket

    def __init__(self):
        this = _mscl.new_Connection()
        try:
            self.this.append(this)
        except:
            self.this = this
    Serial = staticmethod(_mscl.Connection_Serial)
    TcpIp = staticmethod(_mscl.Connection_TcpIp)
    WebSocket = staticmethod(_mscl.Connection_WebSocket)
    Mock = staticmethod(_mscl.Connection_Mock)

    def description(self):
        return _mscl.Connection_description(self)

    def type(self):
        return _mscl.Connection_type(self)

    def disconnect(self):
        return _mscl.Connection_disconnect(self)

    def reconnect(self):
        return _mscl.Connection_reconnect(self)

    def write(self, bytes):
        return _mscl.Connection_write(self, bytes)

    def writeStr(self, bytes):
        return _mscl.Connection_writeStr(self, bytes)

    def clearBuffer(self):
        return _mscl.Connection_clearBuffer(self)

    def byteReadPos(self):
        return _mscl.Connection_byteReadPos(self)

    def byteAppendPos(self):
        return _mscl.Connection_byteAppendPos(self)

    def rawByteMode(self, enable):
        return _mscl.Connection_rawByteMode(self, enable)

    def getRawBytes(self, timeout=0, maxBytes=0, minBytes=0):
        return _mscl.Connection_getRawBytes(self, timeout, maxBytes, minBytes)

    def getRawBytesStr(self, timeout=0, maxBytes=0, minBytes=0):
        return _mscl.Connection_getRawBytesStr(self, timeout, maxBytes, minBytes)

    def getRawBytesWithPattern(self, pattern, timeout=0):
        return _mscl.Connection_getRawBytesWithPattern(self, pattern, timeout)

    def debugMode(self, enable):
        return _mscl.Connection_debugMode(self, enable)

    def getDebugData(self, timeout=0):
        return _mscl.Connection_getDebugData(self, timeout)
    __swig_destroy__ = _mscl.delete_Connection
    __del__ = lambda self: None
Connection_swigregister = _mscl.Connection_swigregister
Connection_swigregister(Connection)

def Connection_Serial(*args):
    return _mscl.Connection_Serial(*args)
Connection_Serial = _mscl.Connection_Serial

def Connection_TcpIp(*args):
    return _mscl.Connection_TcpIp(*args)
Connection_TcpIp = _mscl.Connection_TcpIp

def Connection_WebSocket(host, port):
    return _mscl.Connection_WebSocket(host, port)
Connection_WebSocket = _mscl.Connection_WebSocket

def Connection_Mock():
    return _mscl.Connection_Mock()
Connection_Mock = _mscl.Connection_Mock

class WsdaInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_WsdaInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ipAddress(self):
        return _mscl.WsdaInfo_ipAddress(self)

    def port(self):
        return _mscl.WsdaInfo_port(self)

    def name(self):
        return _mscl.WsdaInfo_name(self)
    __swig_destroy__ = _mscl.delete_WsdaInfo
    __del__ = lambda self: None
WsdaInfo_swigregister = _mscl.WsdaInfo_swigregister
WsdaInfo_swigregister(WsdaInfo)

class WsdaFinder(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_WsdaFinder()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_WsdaFinder
    __del__ = lambda self: None

    def found(self):
        return _mscl.WsdaFinder_found(self)

    def restart(self):
        return _mscl.WsdaFinder_restart(self)
WsdaFinder_swigregister = _mscl.WsdaFinder_swigregister
WsdaFinder_swigregister(WsdaFinder)

class WirelessTypes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    beacon_none = _mscl.WirelessTypes_beacon_none
    beacon_internalTimer = _mscl.WirelessTypes_beacon_internalTimer
    beacon_internalPPS = _mscl.WirelessTypes_beacon_internalPPS
    beacon_externalPPS = _mscl.WirelessTypes_beacon_externalPPS
    microcontroller_18F452 = _mscl.WirelessTypes_microcontroller_18F452
    microcontroller_18F4620 = _mscl.WirelessTypes_microcontroller_18F4620
    microcontroller_18F46K20 = _mscl.WirelessTypes_microcontroller_18F46K20
    microcontroller_18F67K90 = _mscl.WirelessTypes_microcontroller_18F67K90
    microcontroller_EFM32WG990F256 = _mscl.WirelessTypes_microcontroller_EFM32WG990F256
    microcontroller_EFR32FG1P132F256GM48 = _mscl.WirelessTypes_microcontroller_EFR32FG1P132F256GM48
    microcontroller_EFR32MG1P232F256GM48 = _mscl.WirelessTypes_microcontroller_EFR32MG1P232F256GM48
    collectionMethod_logOnly = _mscl.WirelessTypes_collectionMethod_logOnly
    collectionMethod_transmitOnly = _mscl.WirelessTypes_collectionMethod_transmitOnly
    collectionMethod_logAndTransmit = _mscl.WirelessTypes_collectionMethod_logAndTransmit
    dataType_first = _mscl.WirelessTypes_dataType_first
    dataType_uint16_shifted = _mscl.WirelessTypes_dataType_uint16_shifted
    dataType_float32 = _mscl.WirelessTypes_dataType_float32
    dataType_uint16_12bitRes = _mscl.WirelessTypes_dataType_uint16_12bitRes
    dataType_uint32 = _mscl.WirelessTypes_dataType_uint32
    dataType_uint16 = _mscl.WirelessTypes_dataType_uint16
    dataType_float32_noCals = _mscl.WirelessTypes_dataType_float32_noCals
    dataType_uint24_18bitRes = _mscl.WirelessTypes_dataType_uint24_18bitRes
    dataType_uint16_18bitTrunc = _mscl.WirelessTypes_dataType_uint16_18bitTrunc
    dataType_int24_20bit = _mscl.WirelessTypes_dataType_int24_20bit
    dataType_int16_20bitTrunc = _mscl.WirelessTypes_dataType_int16_20bitTrunc
    dataType_uint24 = _mscl.WirelessTypes_dataType_uint24
    dataType_uint16_24bitTrunc = _mscl.WirelessTypes_dataType_uint16_24bitTrunc
    dataType_last = _mscl.WirelessTypes_dataType_last
    dataFormat_raw_uint16 = _mscl.WirelessTypes_dataFormat_raw_uint16
    dataFormat_cal_float = _mscl.WirelessTypes_dataFormat_cal_float
    dataFormat_raw_uint24 = _mscl.WirelessTypes_dataFormat_raw_uint24
    dataFormat_raw_int24 = _mscl.WirelessTypes_dataFormat_raw_int24
    dataFormat_raw_int16 = _mscl.WirelessTypes_dataFormat_raw_int16
    syncMode_continuous = _mscl.WirelessTypes_syncMode_continuous
    syncMode_burst = _mscl.WirelessTypes_syncMode_burst
    samplingMode_sync = _mscl.WirelessTypes_samplingMode_sync
    samplingMode_syncBurst = _mscl.WirelessTypes_samplingMode_syncBurst
    samplingMode_nonSync = _mscl.WirelessTypes_samplingMode_nonSync
    samplingMode_armedDatalog = _mscl.WirelessTypes_samplingMode_armedDatalog
    samplingMode_syncEvent = _mscl.WirelessTypes_samplingMode_syncEvent
    samplingMode_nonSyncEvent = _mscl.WirelessTypes_samplingMode_nonSyncEvent
    defaultMode_idle = _mscl.WirelessTypes_defaultMode_idle
    defaultMode_ldc = _mscl.WirelessTypes_defaultMode_ldc
    defaultMode_datalog = _mscl.WirelessTypes_defaultMode_datalog
    defaultMode_sleep = _mscl.WirelessTypes_defaultMode_sleep
    defaultMode_sync = _mscl.WirelessTypes_defaultMode_sync
    freq_unknown = _mscl.WirelessTypes_freq_unknown
    freq_11 = _mscl.WirelessTypes_freq_11
    freq_12 = _mscl.WirelessTypes_freq_12
    freq_13 = _mscl.WirelessTypes_freq_13
    freq_14 = _mscl.WirelessTypes_freq_14
    freq_15 = _mscl.WirelessTypes_freq_15
    freq_16 = _mscl.WirelessTypes_freq_16
    freq_17 = _mscl.WirelessTypes_freq_17
    freq_18 = _mscl.WirelessTypes_freq_18
    freq_19 = _mscl.WirelessTypes_freq_19
    freq_20 = _mscl.WirelessTypes_freq_20
    freq_21 = _mscl.WirelessTypes_freq_21
    freq_22 = _mscl.WirelessTypes_freq_22
    freq_23 = _mscl.WirelessTypes_freq_23
    freq_24 = _mscl.WirelessTypes_freq_24
    freq_25 = _mscl.WirelessTypes_freq_25
    freq_26 = _mscl.WirelessTypes_freq_26
    power_20dBm = _mscl.WirelessTypes_power_20dBm
    power_16dBm = _mscl.WirelessTypes_power_16dBm
    power_12dBm = _mscl.WirelessTypes_power_12dBm
    power_11dBm = _mscl.WirelessTypes_power_11dBm
    power_10dBm = _mscl.WirelessTypes_power_10dBm
    power_5dBm = _mscl.WirelessTypes_power_5dBm
    power_1dBm = _mscl.WirelessTypes_power_1dBm
    power_0dBm = _mscl.WirelessTypes_power_0dBm
    retransmission_off = _mscl.WirelessTypes_retransmission_off
    retransmission_on = _mscl.WirelessTypes_retransmission_on
    retransmission_disabled = _mscl.WirelessTypes_retransmission_disabled
    trigger_userInit = _mscl.WirelessTypes_trigger_userInit
    trigger_ceiling = _mscl.WirelessTypes_trigger_ceiling
    trigger_floor = _mscl.WirelessTypes_trigger_floor
    trigger_rampUp = _mscl.WirelessTypes_trigger_rampUp
    trigger_rampDown = _mscl.WirelessTypes_trigger_rampDown
    equation_none = _mscl.WirelessTypes_equation_none
    equation_standard = _mscl.WirelessTypes_equation_standard
    unit_none = _mscl.WirelessTypes_unit_none
    unit_other_bits = _mscl.WirelessTypes_unit_other_bits
    unit_strain_strain = _mscl.WirelessTypes_unit_strain_strain
    unit_strain_microStrain = _mscl.WirelessTypes_unit_strain_microStrain
    unit_accel_g = _mscl.WirelessTypes_unit_accel_g
    unit_accel_mPerSec2 = _mscl.WirelessTypes_unit_accel_mPerSec2
    unit_volts_volts = _mscl.WirelessTypes_unit_volts_volts
    unit_volts_millivolts = _mscl.WirelessTypes_unit_volts_millivolts
    unit_volts_microvolts = _mscl.WirelessTypes_unit_volts_microvolts
    unit_temp_celsius = _mscl.WirelessTypes_unit_temp_celsius
    unit_temp_kelvin = _mscl.WirelessTypes_unit_temp_kelvin
    unit_temp_fahrenheit = _mscl.WirelessTypes_unit_temp_fahrenheit
    unit_displacement_meters = _mscl.WirelessTypes_unit_displacement_meters
    unit_displacement_millimeters = _mscl.WirelessTypes_unit_displacement_millimeters
    unit_displacement_micrometers = _mscl.WirelessTypes_unit_displacement_micrometers
    unit_force_lbf = _mscl.WirelessTypes_unit_force_lbf
    unit_force_newtons = _mscl.WirelessTypes_unit_force_newtons
    unit_force_kiloNewtons = _mscl.WirelessTypes_unit_force_kiloNewtons
    unit_mass_kilograms = _mscl.WirelessTypes_unit_mass_kilograms
    unit_pressure_bar = _mscl.WirelessTypes_unit_pressure_bar
    unit_pressure_psi = _mscl.WirelessTypes_unit_pressure_psi
    unit_pressure_atm = _mscl.WirelessTypes_unit_pressure_atm
    unit_pressure_mmHg = _mscl.WirelessTypes_unit_pressure_mmHg
    unit_pressure_pascal = _mscl.WirelessTypes_unit_pressure_pascal
    unit_pressure_megaPascal = _mscl.WirelessTypes_unit_pressure_megaPascal
    unit_pressure_kiloPascal = _mscl.WirelessTypes_unit_pressure_kiloPascal
    unit_angDisplacement_degrees = _mscl.WirelessTypes_unit_angDisplacement_degrees
    unit_angVelocity_degreesPerSec = _mscl.WirelessTypes_unit_angVelocity_degreesPerSec
    unit_angVelocity_radiansPerSec = _mscl.WirelessTypes_unit_angVelocity_radiansPerSec
    unit_other_percent = _mscl.WirelessTypes_unit_other_percent
    unit_freq_rpm = _mscl.WirelessTypes_unit_freq_rpm
    unit_freq_hertz = _mscl.WirelessTypes_unit_freq_hertz
    unit_rh_percentRh = _mscl.WirelessTypes_unit_rh_percentRh
    unit_other_mVperV = _mscl.WirelessTypes_unit_other_mVperV
    unit_accel_milliG = _mscl.WirelessTypes_unit_accel_milliG
    unit_accel_ftPerSec2 = _mscl.WirelessTypes_unit_accel_ftPerSec2
    unit_other_percentLife = _mscl.WirelessTypes_unit_other_percentLife
    unit_other_count = _mscl.WirelessTypes_unit_other_count
    unit_displacement_feet = _mscl.WirelessTypes_unit_displacement_feet
    unit_displacement_inches = _mscl.WirelessTypes_unit_displacement_inches
    unit_displacement_yards = _mscl.WirelessTypes_unit_displacement_yards
    unit_displacement_miles = _mscl.WirelessTypes_unit_displacement_miles
    unit_displacement_nautMiles = _mscl.WirelessTypes_unit_displacement_nautMiles
    unit_displacement_thouInch = _mscl.WirelessTypes_unit_displacement_thouInch
    unit_displacement_hundInch = _mscl.WirelessTypes_unit_displacement_hundInch
    unit_displacement_kilometers = _mscl.WirelessTypes_unit_displacement_kilometers
    unit_displacement_centimeters = _mscl.WirelessTypes_unit_displacement_centimeters
    unit_irradiance_wattsPerSqMeter = _mscl.WirelessTypes_unit_irradiance_wattsPerSqMeter
    unit_par_microEinstein = _mscl.WirelessTypes_unit_par_microEinstein
    unit_mass_pound = _mscl.WirelessTypes_unit_mass_pound
    unit_power_watt = _mscl.WirelessTypes_unit_power_watt
    unit_power_milliwatt = _mscl.WirelessTypes_unit_power_milliwatt
    unit_power_horsepower = _mscl.WirelessTypes_unit_power_horsepower
    unit_reactivePower_var = _mscl.WirelessTypes_unit_reactivePower_var
    unit_energy_wattHour = _mscl.WirelessTypes_unit_energy_wattHour
    unit_energy_kiloWattHour = _mscl.WirelessTypes_unit_energy_kiloWattHour
    unit_reactiveEnergy_VARh = _mscl.WirelessTypes_unit_reactiveEnergy_VARh
    unit_reactiveEnergy_kVARh = _mscl.WirelessTypes_unit_reactiveEnergy_kVARh
    unit_current_ampere = _mscl.WirelessTypes_unit_current_ampere
    unit_current_milliampere = _mscl.WirelessTypes_unit_current_milliampere
    unit_current_microampere = _mscl.WirelessTypes_unit_current_microampere
    unit_pressure_millibar = _mscl.WirelessTypes_unit_pressure_millibar
    unit_pressure_inHg = _mscl.WirelessTypes_unit_pressure_inHg
    unit_rssi_dBm = _mscl.WirelessTypes_unit_rssi_dBm
    unit_freq_kiloHertz = _mscl.WirelessTypes_unit_freq_kiloHertz
    unit_angDisplacement_radians = _mscl.WirelessTypes_unit_angDisplacement_radians
    unit_velocity_metersPerSec = _mscl.WirelessTypes_unit_velocity_metersPerSec
    unit_velocity_kilometersPerSec = _mscl.WirelessTypes_unit_velocity_kilometersPerSec
    unit_velocity_kilometersPerHr = _mscl.WirelessTypes_unit_velocity_kilometersPerHr
    unit_velocity_milesPerHr = _mscl.WirelessTypes_unit_velocity_milesPerHr
    unit_velocity_knots = _mscl.WirelessTypes_unit_velocity_knots
    unit_volume_cubicMeter = _mscl.WirelessTypes_unit_volume_cubicMeter
    unit_volume_cubicFt = _mscl.WirelessTypes_unit_volume_cubicFt
    unit_volume_liters = _mscl.WirelessTypes_unit_volume_liters
    unit_volume_gallon = _mscl.WirelessTypes_unit_volume_gallon
    unit_flowRate_cubicMetersPerSec = _mscl.WirelessTypes_unit_flowRate_cubicMetersPerSec
    unit_flowRate_cubicFtPerSec = _mscl.WirelessTypes_unit_flowRate_cubicFtPerSec
    unit_torque_newtonMeter = _mscl.WirelessTypes_unit_torque_newtonMeter
    unit_torque_footPounds = _mscl.WirelessTypes_unit_torque_footPounds
    unit_torque_inchPounds = _mscl.WirelessTypes_unit_torque_inchPounds
    unit_time_secs = _mscl.WirelessTypes_unit_time_secs
    unit_time_nanosecs = _mscl.WirelessTypes_unit_time_nanosecs
    unit_time_microsecs = _mscl.WirelessTypes_unit_time_microsecs
    unit_time_millisecs = _mscl.WirelessTypes_unit_time_millisecs
    unit_time_minutes = _mscl.WirelessTypes_unit_time_minutes
    unit_time_hours = _mscl.WirelessTypes_unit_time_hours
    unit_time_days = _mscl.WirelessTypes_unit_time_days
    unit_time_weeks = _mscl.WirelessTypes_unit_time_weeks
    unit_other_value = _mscl.WirelessTypes_unit_other_value
    unit_magneticFlux_gauss = _mscl.WirelessTypes_unit_magneticFlux_gauss
    unit_other_gSec = _mscl.WirelessTypes_unit_other_gSec
    unit_other_secsPerSec = _mscl.WirelessTypes_unit_other_secsPerSec
    unit_rssi_dBHz = _mscl.WirelessTypes_unit_rssi_dBHz
    unit_density_kgPerMeter3 = _mscl.WirelessTypes_unit_density_kgPerMeter3
    unit_other_unitless = _mscl.WirelessTypes_unit_other_unitless
    unit_velocity_inchesPerSec = _mscl.WirelessTypes_unit_velocity_inchesPerSec
    unit_force_kg = _mscl.WirelessTypes_unit_force_kg
    unit_rawVoltage_volts = _mscl.WirelessTypes_unit_rawVoltage_volts
    unit_rawVoltage_millivolts = _mscl.WirelessTypes_unit_rawVoltage_millivolts
    unit_rawVoltage_microvolts = _mscl.WirelessTypes_unit_rawVoltage_microvolts
    unit_resistance_ohm = _mscl.WirelessTypes_unit_resistance_ohm
    unit_resistance_milliohm = _mscl.WirelessTypes_unit_resistance_milliohm
    unit_resistance_kiloohm = _mscl.WirelessTypes_unit_resistance_kiloohm
    unit_velocity_mmPerSec = _mscl.WirelessTypes_unit_velocity_mmPerSec
    chType_none = _mscl.WirelessTypes_chType_none
    chType_fullDifferential = _mscl.WirelessTypes_chType_fullDifferential
    chType_singleEnded = _mscl.WirelessTypes_chType_singleEnded
    chType_battery = _mscl.WirelessTypes_chType_battery
    chType_temperature = _mscl.WirelessTypes_chType_temperature
    chType_rh = _mscl.WirelessTypes_chType_rh
    chType_acceleration = _mscl.WirelessTypes_chType_acceleration
    chType_displacement = _mscl.WirelessTypes_chType_displacement
    chType_voltage = _mscl.WirelessTypes_chType_voltage
    chType_diffTemperature = _mscl.WirelessTypes_chType_diffTemperature
    chType_digital = _mscl.WirelessTypes_chType_digital
    chType_tilt = _mscl.WirelessTypes_chType_tilt
    voltageType_singleEnded = _mscl.WirelessTypes_voltageType_singleEnded
    voltageType_differential = _mscl.WirelessTypes_voltageType_differential
    settling_4ms = _mscl.WirelessTypes_settling_4ms
    settling_8ms = _mscl.WirelessTypes_settling_8ms
    settling_16ms = _mscl.WirelessTypes_settling_16ms
    settling_32ms = _mscl.WirelessTypes_settling_32ms
    settling_40ms = _mscl.WirelessTypes_settling_40ms
    settling_48ms = _mscl.WirelessTypes_settling_48ms
    settling_60ms = _mscl.WirelessTypes_settling_60ms
    settling_101ms_90db = _mscl.WirelessTypes_settling_101ms_90db
    settling_120ms_80db = _mscl.WirelessTypes_settling_120ms_80db
    settling_120ms_65db = _mscl.WirelessTypes_settling_120ms_65db
    settling_160ms_69db = _mscl.WirelessTypes_settling_160ms_69db
    settling_200ms = _mscl.WirelessTypes_settling_200ms
    transducer_thermocouple = _mscl.WirelessTypes_transducer_thermocouple
    transducer_rtd = _mscl.WirelessTypes_transducer_rtd
    transducer_thermistor = _mscl.WirelessTypes_transducer_thermistor
    tc_uncompensated = _mscl.WirelessTypes_tc_uncompensated
    tc_K = _mscl.WirelessTypes_tc_K
    tc_J = _mscl.WirelessTypes_tc_J
    tc_R = _mscl.WirelessTypes_tc_R
    tc_S = _mscl.WirelessTypes_tc_S
    tc_T = _mscl.WirelessTypes_tc_T
    tc_E = _mscl.WirelessTypes_tc_E
    tc_B = _mscl.WirelessTypes_tc_B
    tc_N = _mscl.WirelessTypes_tc_N
    tc_customPolynomial = _mscl.WirelessTypes_tc_customPolynomial
    rtd_uncompensated = _mscl.WirelessTypes_rtd_uncompensated
    rtd_pt10 = _mscl.WirelessTypes_rtd_pt10
    rtd_pt50 = _mscl.WirelessTypes_rtd_pt50
    rtd_pt100 = _mscl.WirelessTypes_rtd_pt100
    rtd_pt200 = _mscl.WirelessTypes_rtd_pt200
    rtd_pt500 = _mscl.WirelessTypes_rtd_pt500
    rtd_pt1000 = _mscl.WirelessTypes_rtd_pt1000
    rtd_2wire = _mscl.WirelessTypes_rtd_2wire
    rtd_3wire = _mscl.WirelessTypes_rtd_3wire
    rtd_4wire = _mscl.WirelessTypes_rtd_4wire
    thermistor_uncompensated = _mscl.WirelessTypes_thermistor_uncompensated
    thermistor_44004_44033 = _mscl.WirelessTypes_thermistor_44004_44033
    thermistor_44005_44030 = _mscl.WirelessTypes_thermistor_44005_44030
    thermistor_44007_44034 = _mscl.WirelessTypes_thermistor_44007_44034
    thermistor_44006_44031 = _mscl.WirelessTypes_thermistor_44006_44031
    thermistor_44008_44032 = _mscl.WirelessTypes_thermistor_44008_44032
    thermistor_ysi_400 = _mscl.WirelessTypes_thermistor_ysi_400
    sampleRate_104170Hz = _mscl.WirelessTypes_sampleRate_104170Hz
    sampleRate_78125Hz = _mscl.WirelessTypes_sampleRate_78125Hz
    sampleRate_62500Hz = _mscl.WirelessTypes_sampleRate_62500Hz
    sampleRate_25000Hz = _mscl.WirelessTypes_sampleRate_25000Hz
    sampleRate_12500Hz = _mscl.WirelessTypes_sampleRate_12500Hz
    sampleRate_3200Hz = _mscl.WirelessTypes_sampleRate_3200Hz
    sampleRate_1600Hz = _mscl.WirelessTypes_sampleRate_1600Hz
    sampleRate_800Hz = _mscl.WirelessTypes_sampleRate_800Hz
    sampleRate_300Hz = _mscl.WirelessTypes_sampleRate_300Hz
    sampleRate_1kHz = _mscl.WirelessTypes_sampleRate_1kHz
    sampleRate_2kHz = _mscl.WirelessTypes_sampleRate_2kHz
    sampleRate_3kHz = _mscl.WirelessTypes_sampleRate_3kHz
    sampleRate_4kHz = _mscl.WirelessTypes_sampleRate_4kHz
    sampleRate_5kHz = _mscl.WirelessTypes_sampleRate_5kHz
    sampleRate_6kHz = _mscl.WirelessTypes_sampleRate_6kHz
    sampleRate_7kHz = _mscl.WirelessTypes_sampleRate_7kHz
    sampleRate_8kHz = _mscl.WirelessTypes_sampleRate_8kHz
    sampleRate_9kHz = _mscl.WirelessTypes_sampleRate_9kHz
    sampleRate_10kHz = _mscl.WirelessTypes_sampleRate_10kHz
    sampleRate_20kHz = _mscl.WirelessTypes_sampleRate_20kHz
    sampleRate_30kHz = _mscl.WirelessTypes_sampleRate_30kHz
    sampleRate_40kHz = _mscl.WirelessTypes_sampleRate_40kHz
    sampleRate_50kHz = _mscl.WirelessTypes_sampleRate_50kHz
    sampleRate_60kHz = _mscl.WirelessTypes_sampleRate_60kHz
    sampleRate_70kHz = _mscl.WirelessTypes_sampleRate_70kHz
    sampleRate_80kHz = _mscl.WirelessTypes_sampleRate_80kHz
    sampleRate_90kHz = _mscl.WirelessTypes_sampleRate_90kHz
    sampleRate_100kHz = _mscl.WirelessTypes_sampleRate_100kHz
    sampleRate_887Hz = _mscl.WirelessTypes_sampleRate_887Hz
    sampleRate_8192Hz = _mscl.WirelessTypes_sampleRate_8192Hz
    sampleRate_4096Hz = _mscl.WirelessTypes_sampleRate_4096Hz
    sampleRate_2048Hz = _mscl.WirelessTypes_sampleRate_2048Hz
    sampleRate_1024Hz = _mscl.WirelessTypes_sampleRate_1024Hz
    sampleRate_512Hz = _mscl.WirelessTypes_sampleRate_512Hz
    sampleRate_256Hz = _mscl.WirelessTypes_sampleRate_256Hz
    sampleRate_128Hz = _mscl.WirelessTypes_sampleRate_128Hz
    sampleRate_64Hz = _mscl.WirelessTypes_sampleRate_64Hz
    sampleRate_32Hz = _mscl.WirelessTypes_sampleRate_32Hz
    sampleRate_16Hz = _mscl.WirelessTypes_sampleRate_16Hz
    sampleRate_8Hz = _mscl.WirelessTypes_sampleRate_8Hz
    sampleRate_4Hz = _mscl.WirelessTypes_sampleRate_4Hz
    sampleRate_2Hz = _mscl.WirelessTypes_sampleRate_2Hz
    sampleRate_1Hz = _mscl.WirelessTypes_sampleRate_1Hz
    sampleRate_2Sec = _mscl.WirelessTypes_sampleRate_2Sec
    sampleRate_5Sec = _mscl.WirelessTypes_sampleRate_5Sec
    sampleRate_10Sec = _mscl.WirelessTypes_sampleRate_10Sec
    sampleRate_30Sec = _mscl.WirelessTypes_sampleRate_30Sec
    sampleRate_1Min = _mscl.WirelessTypes_sampleRate_1Min
    sampleRate_2Min = _mscl.WirelessTypes_sampleRate_2Min
    sampleRate_5Min = _mscl.WirelessTypes_sampleRate_5Min
    sampleRate_10Min = _mscl.WirelessTypes_sampleRate_10Min
    sampleRate_30Min = _mscl.WirelessTypes_sampleRate_30Min
    sampleRate_60Min = _mscl.WirelessTypes_sampleRate_60Min
    sampleRate_24Hours = _mscl.WirelessTypes_sampleRate_24Hours
    region_usa = _mscl.WirelessTypes_region_usa
    region_europe = _mscl.WirelessTypes_region_europe
    region_japan = _mscl.WirelessTypes_region_japan
    region_other = _mscl.WirelessTypes_region_other
    region_brazil = _mscl.WirelessTypes_region_brazil
    region_china = _mscl.WirelessTypes_region_china
    chSetting_inputRange = _mscl.WirelessTypes_chSetting_inputRange
    chSetting_filterSettlingTime = _mscl.WirelessTypes_chSetting_filterSettlingTime
    chSetting_thermocoupleType = _mscl.WirelessTypes_chSetting_thermocoupleType
    chSetting_linearEquation = _mscl.WirelessTypes_chSetting_linearEquation
    chSetting_unit = _mscl.WirelessTypes_chSetting_unit
    chSetting_equationType = _mscl.WirelessTypes_chSetting_equationType
    chSetting_hardwareOffset = _mscl.WirelessTypes_chSetting_hardwareOffset
    chSetting_autoBalance = _mscl.WirelessTypes_chSetting_autoBalance
    chSetting_gaugeFactor = _mscl.WirelessTypes_chSetting_gaugeFactor
    chSetting_antiAliasingFilter = _mscl.WirelessTypes_chSetting_antiAliasingFilter
    chSetting_legacyShuntCal = _mscl.WirelessTypes_chSetting_legacyShuntCal
    chSetting_autoShuntCal = _mscl.WirelessTypes_chSetting_autoShuntCal
    chSetting_lowPassFilter = _mscl.WirelessTypes_chSetting_lowPassFilter
    chSetting_highPassFilter = _mscl.WirelessTypes_chSetting_highPassFilter
    chSetting_tempSensorOptions = _mscl.WirelessTypes_chSetting_tempSensorOptions
    chSetting_debounceFilter = _mscl.WirelessTypes_chSetting_debounceFilter
    chSetting_pullUpResistor = _mscl.WirelessTypes_chSetting_pullUpResistor
    autobalance_success = _mscl.WirelessTypes_autobalance_success
    autobalance_maybeInvalid = _mscl.WirelessTypes_autobalance_maybeInvalid
    autobalance_notSupportedByNode = _mscl.WirelessTypes_autobalance_notSupportedByNode
    autobalance_notSupportedByCh = _mscl.WirelessTypes_autobalance_notSupportedByCh
    autobalance_targetOutOfRange = _mscl.WirelessTypes_autobalance_targetOutOfRange
    autobalance_failed = _mscl.WirelessTypes_autobalance_failed
    autobalance_legacyNone = _mscl.WirelessTypes_autobalance_legacyNone
    autobalance_notComplete = _mscl.WirelessTypes_autobalance_notComplete
    autocal_success = _mscl.WirelessTypes_autocal_success
    autocal_maybeInvalid_applied = _mscl.WirelessTypes_autocal_maybeInvalid_applied
    autocal_maybeInvalid_notApplied = _mscl.WirelessTypes_autocal_maybeInvalid_notApplied
    autocal_notComplete = _mscl.WirelessTypes_autocal_notComplete
    autocalError_none = _mscl.WirelessTypes_autocalError_none
    autocalError_sensorDetached = _mscl.WirelessTypes_autocalError_sensorDetached
    autocalError_sensorShorted = _mscl.WirelessTypes_autocalError_sensorShorted
    autocalError_unsupportedChannel = _mscl.WirelessTypes_autocalError_unsupportedChannel
    autocalError_baseHighRail = _mscl.WirelessTypes_autocalError_baseHighRail
    autocalError_baseLowRail = _mscl.WirelessTypes_autocalError_baseLowRail
    autocalError_shuntHighRail = _mscl.WirelessTypes_autocalError_shuntHighRail
    autocalError_shuntLowRail = _mscl.WirelessTypes_autocalError_shuntLowRail
    autocalError_ramp = _mscl.WirelessTypes_autocalError_ramp
    autocalError_noShunt = _mscl.WirelessTypes_autocalError_noShunt
    autocalError_timeout = _mscl.WirelessTypes_autocalError_timeout
    fatigueMode_angleStrain = _mscl.WirelessTypes_fatigueMode_angleStrain
    fatigueMode_distributedAngle = _mscl.WirelessTypes_fatigueMode_distributedAngle
    fatigueMode_rawGaugeStrain = _mscl.WirelessTypes_fatigueMode_rawGaugeStrain
    eventTrigger_ceiling = _mscl.WirelessTypes_eventTrigger_ceiling
    eventTrigger_floor = _mscl.WirelessTypes_eventTrigger_floor
    filter_33000hz = _mscl.WirelessTypes_filter_33000hz
    filter_20000hz = _mscl.WirelessTypes_filter_20000hz
    filter_10000hz = _mscl.WirelessTypes_filter_10000hz
    filter_5222hz = _mscl.WirelessTypes_filter_5222hz
    filter_5000hz = _mscl.WirelessTypes_filter_5000hz
    filter_4416hz = _mscl.WirelessTypes_filter_4416hz
    filter_4096hz = _mscl.WirelessTypes_filter_4096hz
    filter_4000hz = _mscl.WirelessTypes_filter_4000hz
    filter_2208hz = _mscl.WirelessTypes_filter_2208hz
    filter_2048hz = _mscl.WirelessTypes_filter_2048hz
    filter_2000hz = _mscl.WirelessTypes_filter_2000hz
    filter_1104hz = _mscl.WirelessTypes_filter_1104hz
    filter_1024hz = _mscl.WirelessTypes_filter_1024hz
    filter_1000hz = _mscl.WirelessTypes_filter_1000hz
    filter_800hz = _mscl.WirelessTypes_filter_800hz
    filter_552hz = _mscl.WirelessTypes_filter_552hz
    filter_512hz = _mscl.WirelessTypes_filter_512hz
    filter_500hz = _mscl.WirelessTypes_filter_500hz
    filter_418hz = _mscl.WirelessTypes_filter_418hz
    filter_294hz = _mscl.WirelessTypes_filter_294hz
    filter_256hz = _mscl.WirelessTypes_filter_256hz
    filter_250hz = _mscl.WirelessTypes_filter_250hz
    filter_209hz = _mscl.WirelessTypes_filter_209hz
    filter_200hz = _mscl.WirelessTypes_filter_200hz
    filter_147hz = _mscl.WirelessTypes_filter_147hz
    filter_128hz = _mscl.WirelessTypes_filter_128hz
    filter_125hz = _mscl.WirelessTypes_filter_125hz
    filter_104hz = _mscl.WirelessTypes_filter_104hz
    filter_100hz = _mscl.WirelessTypes_filter_100hz
    filter_62hz = _mscl.WirelessTypes_filter_62hz
    filter_52hz = _mscl.WirelessTypes_filter_52hz
    filter_50hz = _mscl.WirelessTypes_filter_50hz
    filter_31hz = _mscl.WirelessTypes_filter_31hz
    filter_26hz = _mscl.WirelessTypes_filter_26hz
    filter_12_66hz = _mscl.WirelessTypes_filter_12_66hz
    filter_2_6hz = _mscl.WirelessTypes_filter_2_6hz
    highPass_off = _mscl.WirelessTypes_highPass_off
    highPass_auto = _mscl.WirelessTypes_highPass_auto
    storageLimit_overwrite = _mscl.WirelessTypes_storageLimit_overwrite
    storageLimit_stop = _mscl.WirelessTypes_storageLimit_stop
    range_14_545mV = _mscl.WirelessTypes_range_14_545mV
    range_10_236mV = _mscl.WirelessTypes_range_10_236mV
    range_7_608mV = _mscl.WirelessTypes_range_7_608mV
    range_4_046mV = _mscl.WirelessTypes_range_4_046mV
    range_2_008mV = _mscl.WirelessTypes_range_2_008mV
    range_1_511mV = _mscl.WirelessTypes_range_1_511mV
    range_1_001mV = _mscl.WirelessTypes_range_1_001mV
    range_0_812mV = _mscl.WirelessTypes_range_0_812mV
    range_75mV = _mscl.WirelessTypes_range_75mV
    range_37_5mV = _mscl.WirelessTypes_range_37_5mV
    range_18_75mV = _mscl.WirelessTypes_range_18_75mV
    range_9_38mV = _mscl.WirelessTypes_range_9_38mV
    range_4_69mV = _mscl.WirelessTypes_range_4_69mV
    range_2_34mV = _mscl.WirelessTypes_range_2_34mV
    range_1_17mV = _mscl.WirelessTypes_range_1_17mV
    range_0_586mV = _mscl.WirelessTypes_range_0_586mV
    range_70mV = _mscl.WirelessTypes_range_70mV
    range_35mV = _mscl.WirelessTypes_range_35mV
    range_17_5mV = _mscl.WirelessTypes_range_17_5mV
    range_8_75mV = _mscl.WirelessTypes_range_8_75mV
    range_4_38mV = _mscl.WirelessTypes_range_4_38mV
    range_2_19mV = _mscl.WirelessTypes_range_2_19mV
    range_1_09mV = _mscl.WirelessTypes_range_1_09mV
    range_0_547mV = _mscl.WirelessTypes_range_0_547mV
    range_44mV = _mscl.WirelessTypes_range_44mV
    range_30mV = _mscl.WirelessTypes_range_30mV
    range_20mV = _mscl.WirelessTypes_range_20mV
    range_15mV = _mscl.WirelessTypes_range_15mV
    range_10mV = _mscl.WirelessTypes_range_10mV
    range_5mV = _mscl.WirelessTypes_range_5mV
    range_3mV = _mscl.WirelessTypes_range_3mV
    range_2mV = _mscl.WirelessTypes_range_2mV
    range_6mV = _mscl.WirelessTypes_range_6mV
    range_1mV = _mscl.WirelessTypes_range_1mV
    range_50mV = _mscl.WirelessTypes_range_50mV
    range_2_5mV = _mscl.WirelessTypes_range_2_5mV
    range_0_6mV = _mscl.WirelessTypes_range_0_6mV
    range_0_35mV = _mscl.WirelessTypes_range_0_35mV
    range_0_1mV = _mscl.WirelessTypes_range_0_1mV
    range_156mV = _mscl.WirelessTypes_range_156mV
    range_78_1mV = _mscl.WirelessTypes_range_78_1mV
    range_39mV = _mscl.WirelessTypes_range_39mV
    range_19_5mV = _mscl.WirelessTypes_range_19_5mV
    range_9_76mV = _mscl.WirelessTypes_range_9_76mV
    range_4_88mV = _mscl.WirelessTypes_range_4_88mV
    range_2_44mV = _mscl.WirelessTypes_range_2_44mV
    range_1_22mV = _mscl.WirelessTypes_range_1_22mV
    range_10_24V = _mscl.WirelessTypes_range_10_24V
    range_5_12V = _mscl.WirelessTypes_range_5_12V
    range_2_56V = _mscl.WirelessTypes_range_2_56V
    range_0to10_24V = _mscl.WirelessTypes_range_0to10_24V
    range_0to5_12V = _mscl.WirelessTypes_range_0to5_12V
    range_1_147V = _mscl.WirelessTypes_range_1_147V
    range_585mV = _mscl.WirelessTypes_range_585mV
    range_292_5mV = _mscl.WirelessTypes_range_292_5mV
    range_146_25mV = _mscl.WirelessTypes_range_146_25mV
    range_73_13mV = _mscl.WirelessTypes_range_73_13mV
    range_36_56mV = _mscl.WirelessTypes_range_36_56mV
    range_18_23mV = _mscl.WirelessTypes_range_18_23mV
    range_9_14mV = _mscl.WirelessTypes_range_9_14mV
    range_5_74V = _mscl.WirelessTypes_range_5_74V
    range_2_93V = _mscl.WirelessTypes_range_2_93V
    range_1_46V = _mscl.WirelessTypes_range_1_46V
    range_731_3mV = _mscl.WirelessTypes_range_731_3mV
    range_365_6mV = _mscl.WirelessTypes_range_365_6mV
    range_182_8mV = _mscl.WirelessTypes_range_182_8mV
    range_91_4mV = _mscl.WirelessTypes_range_91_4mV
    range_45_7mV = _mscl.WirelessTypes_range_45_7mV
    range_62_5mV = _mscl.WirelessTypes_range_62_5mV
    range_31_25mV = _mscl.WirelessTypes_range_31_25mV
    range_15_63mV = _mscl.WirelessTypes_range_15_63mV
    range_7_81mV = _mscl.WirelessTypes_range_7_81mV
    range_3_91mV = _mscl.WirelessTypes_range_3_91mV
    range_1_95mV = _mscl.WirelessTypes_range_1_95mV
    range_0_976mV = _mscl.WirelessTypes_range_0_976mV
    range_0_488mV = _mscl.WirelessTypes_range_0_488mV
    range_2G = _mscl.WirelessTypes_range_2G
    range_4G = _mscl.WirelessTypes_range_4G
    range_8G = _mscl.WirelessTypes_range_8G
    range_10G = _mscl.WirelessTypes_range_10G
    range_20G = _mscl.WirelessTypes_range_20G
    range_40G = _mscl.WirelessTypes_range_40G
    range_2_5V = _mscl.WirelessTypes_range_2_5V
    range_1_25V = _mscl.WirelessTypes_range_1_25V
    range_625mV = _mscl.WirelessTypes_range_625mV
    range_312_5mV = _mscl.WirelessTypes_range_312_5mV
    range_156_25mV = _mscl.WirelessTypes_range_156_25mV
    range_78_125mV = _mscl.WirelessTypes_range_78_125mV
    range_39_063mV = _mscl.WirelessTypes_range_39_063mV
    range_19_532mV = _mscl.WirelessTypes_range_19_532mV
    range_0to2_5V = _mscl.WirelessTypes_range_0to2_5V
    range_0to1_25V = _mscl.WirelessTypes_range_0to1_25V
    range_0to625mV = _mscl.WirelessTypes_range_0to625mV
    range_0to312_5mV = _mscl.WirelessTypes_range_0to312_5mV
    range_0to156_25mV = _mscl.WirelessTypes_range_0to156_25mV
    range_0to78_125mV = _mscl.WirelessTypes_range_0to78_125mV
    range_0to39_063mV = _mscl.WirelessTypes_range_0to39_063mV
    range_0to19_532mV = _mscl.WirelessTypes_range_0to19_532mV
    range_9_766mV = _mscl.WirelessTypes_range_9_766mV
    range_1_35V_or_0to2026408518ohm = _mscl.WirelessTypes_range_1_35V_or_0to2026408518ohm
    range_1_25V_or_0to10000ohm = _mscl.WirelessTypes_range_1_25V_or_0to10000ohm
    range_625mV_or_0to2580ohm = _mscl.WirelessTypes_range_625mV_or_0to2580ohm
    range_312_5mV_or_0to1290ohm = _mscl.WirelessTypes_range_312_5mV_or_0to1290ohm
    range_156_25mV_or_0to645ohm = _mscl.WirelessTypes_range_156_25mV_or_0to645ohm
    range_78_125mV_or_0to322ohm = _mscl.WirelessTypes_range_78_125mV_or_0to322ohm
    range_39_0625mV_or_0to161ohm = _mscl.WirelessTypes_range_39_0625mV_or_0to161ohm
    range_19_5313mV_or_0to80ohm = _mscl.WirelessTypes_range_19_5313mV_or_0to80ohm
    range_750mV = _mscl.WirelessTypes_range_750mV
    range_375mV = _mscl.WirelessTypes_range_375mV
    range_187_5mV = _mscl.WirelessTypes_range_187_5mV
    range_93_75mV = _mscl.WirelessTypes_range_93_75mV
    range_46_875mV = _mscl.WirelessTypes_range_46_875mV
    range_23_438mV = _mscl.WirelessTypes_range_23_438mV
    range_11_719mV = _mscl.WirelessTypes_range_11_719mV
    range_5_859mV = _mscl.WirelessTypes_range_5_859mV
    range_0to1_5V = _mscl.WirelessTypes_range_0to1_5V
    range_0to750mV = _mscl.WirelessTypes_range_0to750mV
    range_0to375mV = _mscl.WirelessTypes_range_0to375mV
    range_0to187_5mV = _mscl.WirelessTypes_range_0to187_5mV
    range_0to93_75mV = _mscl.WirelessTypes_range_0to93_75mV
    range_0to46_875mV = _mscl.WirelessTypes_range_0to46_875mV
    range_0to23_438mV = _mscl.WirelessTypes_range_0to23_438mV
    range_0to11_719mV = _mscl.WirelessTypes_range_0to11_719mV
    range_invalid = _mscl.WirelessTypes_range_invalid
    dataMode_none = _mscl.WirelessTypes_dataMode_none
    dataMode_raw = _mscl.WirelessTypes_dataMode_raw
    dataMode_derived = _mscl.WirelessTypes_dataMode_derived
    dataMode_raw_derived = _mscl.WirelessTypes_dataMode_raw_derived
    derivedCategory_rms = _mscl.WirelessTypes_derivedCategory_rms
    derivedCategory_peakToPeak = _mscl.WirelessTypes_derivedCategory_peakToPeak
    derivedCategory_velocity = _mscl.WirelessTypes_derivedCategory_velocity
    derivedCategory_crestFactor = _mscl.WirelessTypes_derivedCategory_crestFactor
    derivedCategory_mean = _mscl.WirelessTypes_derivedCategory_mean
    derivedAlgId_rms = _mscl.WirelessTypes_derivedAlgId_rms
    derivedAlgId_peakToPeak = _mscl.WirelessTypes_derivedAlgId_peakToPeak
    derivedAlgId_ips = _mscl.WirelessTypes_derivedAlgId_ips
    derivedAlgId_crestFactor = _mscl.WirelessTypes_derivedAlgId_crestFactor
    derivedAlgId_mean = _mscl.WirelessTypes_derivedAlgId_mean
    derivedAlgId_mmps = _mscl.WirelessTypes_derivedAlgId_mmps
    derivedVelocity_ips = _mscl.WirelessTypes_derivedVelocity_ips
    derivedVelocity_mmps = _mscl.WirelessTypes_derivedVelocity_mmps
    commProtocol_lxrs = _mscl.WirelessTypes_commProtocol_lxrs
    commProtocol_lxrsPlus = _mscl.WirelessTypes_commProtocol_lxrsPlus
    voltage_5120mV = _mscl.WirelessTypes_voltage_5120mV
    voltage_5000mV = _mscl.WirelessTypes_voltage_5000mV
    voltage_4096mV = _mscl.WirelessTypes_voltage_4096mV
    voltage_3000mV = _mscl.WirelessTypes_voltage_3000mV
    voltage_2800mV = _mscl.WirelessTypes_voltage_2800mV
    voltage_2700mV = _mscl.WirelessTypes_voltage_2700mV
    voltage_2500mV = _mscl.WirelessTypes_voltage_2500mV
    voltage_1500mV = _mscl.WirelessTypes_voltage_1500mV
    sensorOutputMode_vibration = _mscl.WirelessTypes_sensorOutputMode_vibration
    sensorOutputMode_tilt = _mscl.WirelessTypes_sensorOutputMode_tilt
    UNKNOWN_RSSI = _mscl.WirelessTypes_UNKNOWN_RSSI

    def __init__(self):
        this = _mscl.new_WirelessTypes()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_WirelessTypes
    __del__ = lambda self: None
WirelessTypes_swigregister = _mscl.WirelessTypes_swigregister
WirelessTypes_swigregister(WirelessTypes)

class SampleRate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rateType_seconds = _mscl.SampleRate_rateType_seconds
    rateType_hertz = _mscl.SampleRate_rateType_hertz
    rateType_event = _mscl.SampleRate_rateType_event

    def __init__(self, *args):
        this = _mscl.new_SampleRate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __str__(self):
        return _mscl.SampleRate___str__(self)

    def prettyStr(self):
        return _mscl.SampleRate_prettyStr(self)

    def samplePeriod(self):
        return _mscl.SampleRate_samplePeriod(self)

    def samplesPerSecond(self):
        return _mscl.SampleRate_samplesPerSecond(self)

    def rateType(self):
        return _mscl.SampleRate_rateType(self)

    def samples(self):
        return _mscl.SampleRate_samples(self)

    def toWirelessSampleRate(self):
        return _mscl.SampleRate_toWirelessSampleRate(self)
    Hertz = staticmethod(_mscl.SampleRate_Hertz)
    KiloHertz = staticmethod(_mscl.SampleRate_KiloHertz)
    Seconds = staticmethod(_mscl.SampleRate_Seconds)
    Event = staticmethod(_mscl.SampleRate_Event)
    FromWirelessEepromValue = staticmethod(_mscl.SampleRate_FromWirelessEepromValue)
    __swig_destroy__ = _mscl.delete_SampleRate
    __del__ = lambda self: None
SampleRate_swigregister = _mscl.SampleRate_swigregister
SampleRate_swigregister(SampleRate)

def SampleRate_Hertz(samplesPerSecond):
    return _mscl.SampleRate_Hertz(samplesPerSecond)
SampleRate_Hertz = _mscl.SampleRate_Hertz

def SampleRate_KiloHertz(kSamplesPerSecond):
    return _mscl.SampleRate_KiloHertz(kSamplesPerSecond)
SampleRate_KiloHertz = _mscl.SampleRate_KiloHertz

def SampleRate_Seconds(secondsBetweenSamples):
    return _mscl.SampleRate_Seconds(secondsBetweenSamples)
SampleRate_Seconds = _mscl.SampleRate_Seconds

def SampleRate_Event():
    return _mscl.SampleRate_Event()
SampleRate_Event = _mscl.SampleRate_Event

def SampleRate_FromWirelessEepromValue(eepromValue):
    return _mscl.SampleRate_FromWirelessEepromValue(eepromValue)
SampleRate_FromWirelessEepromValue = _mscl.SampleRate_FromWirelessEepromValue

class Vector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_Vector()
        try:
            self.this.append(this)
        except:
            self.this = this

    def valuesType(self):
        return _mscl.Vector_valuesType(self)

    def size(self):
        return _mscl.Vector_size(self)

    def as_floatAt(self, index):
        return _mscl.Vector_as_floatAt(self, index)

    def as_uint16At(self, index):
        return _mscl.Vector_as_uint16At(self, index)

    def as_uint8At(self, index):
        return _mscl.Vector_as_uint8At(self, index)

    def __str__(self):
        return _mscl.Vector___str__(self)
    __swig_destroy__ = _mscl.delete_Vector
    __del__ = lambda self: None
Vector_swigregister = _mscl.Vector_swigregister
Vector_swigregister(Vector)

class Matrix(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_Matrix()
        try:
            self.this.append(this)
        except:
            self.this = this

    def valuesType(self):
        return _mscl.Matrix_valuesType(self)

    def rows(self):
        return _mscl.Matrix_rows(self)

    def columns(self):
        return _mscl.Matrix_columns(self)

    def as_floatAt(self, row, column):
        return _mscl.Matrix_as_floatAt(self, row, column)

    def as_uint16At(self, row, column):
        return _mscl.Matrix_as_uint16At(self, row, column)

    def as_uint8At(self, row, column):
        return _mscl.Matrix_as_uint8At(self, row, column)

    def __str__(self):
        return _mscl.Matrix___str__(self)
    __swig_destroy__ = _mscl.delete_Matrix
    __del__ = lambda self: None
Matrix_swigregister = _mscl.Matrix_swigregister
Matrix_swigregister(Matrix)

class StructuralHealth(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, angle, uptime, damage, processingRate, histogram):
        this = _mscl.new_StructuralHealth(angle, uptime, damage, processingRate, histogram)
        try:
            self.this.append(this)
        except:
            self.this = this

    def angle(self):
        return _mscl.StructuralHealth_angle(self)

    def uptime(self):
        return _mscl.StructuralHealth_uptime(self)

    def damage(self):
        return _mscl.StructuralHealth_damage(self)

    def processingRate(self):
        return _mscl.StructuralHealth_processingRate(self)

    def histogram(self):
        return _mscl.StructuralHealth_histogram(self)
    __swig_destroy__ = _mscl.delete_StructuralHealth
    __del__ = lambda self: None
StructuralHealth_swigregister = _mscl.StructuralHealth_swigregister
StructuralHealth_swigregister(StructuralHealth)

class DataPoint(Value):
    thisown = _swig_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
    channelPropertyId_angle = _mscl.DataPoint_channelPropertyId_angle
    channelPropertyId_derivedFrom = _mscl.DataPoint_channelPropertyId_derivedFrom
    channelPropertyId_derivedAlgorithmId = _mscl.DataPoint_channelPropertyId_derivedAlgorithmId
    __swig_destroy__ = _mscl.delete_DataPoint
    __del__ = lambda self: None

    def channelProperty(self, id):
        return _mscl.DataPoint_channelProperty(self, id)

    def as_Vector(self):
        return _mscl.DataPoint_as_Vector(self)

    def as_Matrix(self):
        return _mscl.DataPoint_as_Matrix(self)

    def as_Timestamp(self):
        return _mscl.DataPoint_as_Timestamp(self)

    def as_Bytes(self):
        return _mscl.DataPoint_as_Bytes(self)

    def as_StructuralHealth(self):
        return _mscl.DataPoint_as_StructuralHealth(self)

    def as_RfSweep(self):
        return _mscl.DataPoint_as_RfSweep(self)

    def as_string(self):
        return _mscl.DataPoint_as_string(self)
DataPoint_swigregister = _mscl.DataPoint_swigregister
DataPoint_swigregister(DataPoint)

class ConfigIssue(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CONFIG_SAMPLING_MODE = _mscl.ConfigIssue_CONFIG_SAMPLING_MODE
    CONFIG_ACTIVE_CHANNELS = _mscl.ConfigIssue_CONFIG_ACTIVE_CHANNELS
    CONFIG_SAMPLE_RATE = _mscl.ConfigIssue_CONFIG_SAMPLE_RATE
    CONFIG_SWEEPS = _mscl.ConfigIssue_CONFIG_SWEEPS
    CONFIG_UNLIMITED_DURATION = _mscl.ConfigIssue_CONFIG_UNLIMITED_DURATION
    CONFIG_DATA_FORMAT = _mscl.ConfigIssue_CONFIG_DATA_FORMAT
    CONFIG_DATA_COLLECTION_METHOD = _mscl.ConfigIssue_CONFIG_DATA_COLLECTION_METHOD
    CONFIG_TIME_BETWEEN_BURSTS = _mscl.ConfigIssue_CONFIG_TIME_BETWEEN_BURSTS
    CONFIG_THERMOCOUPLE_TYPE = _mscl.ConfigIssue_CONFIG_THERMOCOUPLE_TYPE
    CONFIG_FILTER_SETTLING_TIME = _mscl.ConfigIssue_CONFIG_FILTER_SETTLING_TIME
    CONFIG_BUTTON = _mscl.ConfigIssue_CONFIG_BUTTON
    CONFIG_ANALOG_PAIR = _mscl.ConfigIssue_CONFIG_ANALOG_PAIR
    CONFIG_INPUT_RANGE = _mscl.ConfigIssue_CONFIG_INPUT_RANGE
    CONFIG_INACTIVITY_TIMEOUT = _mscl.ConfigIssue_CONFIG_INACTIVITY_TIMEOUT
    CONFIG_CHECK_RADIO_INTERVAL = _mscl.ConfigIssue_CONFIG_CHECK_RADIO_INTERVAL
    CONFIG_LOST_BEACON_TIMEOUT = _mscl.ConfigIssue_CONFIG_LOST_BEACON_TIMEOUT
    CONFIG_DEFAULT_MODE = _mscl.ConfigIssue_CONFIG_DEFAULT_MODE
    CONFIG_TRANSMIT_POWER = _mscl.ConfigIssue_CONFIG_TRANSMIT_POWER
    CONFIG_LINEAR_EQUATION = _mscl.ConfigIssue_CONFIG_LINEAR_EQUATION
    CONFIG_FATIGUE = _mscl.ConfigIssue_CONFIG_FATIGUE
    CONFIG_FATIGUE_MODE = _mscl.ConfigIssue_CONFIG_FATIGUE_MODE
    CONFIG_FATIGUE_ANGLE_ID = _mscl.ConfigIssue_CONFIG_FATIGUE_ANGLE_ID
    CONFIG_FATIGUE_SN_CURVE = _mscl.ConfigIssue_CONFIG_FATIGUE_SN_CURVE
    CONFIG_FATIGUE_DIST_NUM_ANGLES = _mscl.ConfigIssue_CONFIG_FATIGUE_DIST_NUM_ANGLES
    CONFIG_FATIGUE_DIST_ANGLE = _mscl.ConfigIssue_CONFIG_FATIGUE_DIST_ANGLE
    CONFIG_HISTOGRAM = _mscl.ConfigIssue_CONFIG_HISTOGRAM
    CONFIG_HISTOGRAM_TX_RATE = _mscl.ConfigIssue_CONFIG_HISTOGRAM_TX_RATE
    CONFIG_HARDWARE_OFFSET = _mscl.ConfigIssue_CONFIG_HARDWARE_OFFSET
    CONFIG_ACTIVITY_SENSE = _mscl.ConfigIssue_CONFIG_ACTIVITY_SENSE
    CONFIG_GAUGE_FACTOR = _mscl.ConfigIssue_CONFIG_GAUGE_FACTOR
    CONFIG_EVENT_TRIGGER = _mscl.ConfigIssue_CONFIG_EVENT_TRIGGER
    CONFIG_EVENT_TRIGGER_DURATION = _mscl.ConfigIssue_CONFIG_EVENT_TRIGGER_DURATION
    CONFIG_EVENT_TRIGGER_MASK = _mscl.ConfigIssue_CONFIG_EVENT_TRIGGER_MASK
    CONFIG_DIAGNOSTIC_INTERVAL = _mscl.ConfigIssue_CONFIG_DIAGNOSTIC_INTERVAL
    CONFIG_ANTI_ALIASING_FILTER = _mscl.ConfigIssue_CONFIG_ANTI_ALIASING_FILTER
    CONFIG_STORAGE_LIMIT_MODE = _mscl.ConfigIssue_CONFIG_STORAGE_LIMIT_MODE
    CONFIG_SENSOR_DELAY = _mscl.ConfigIssue_CONFIG_SENSOR_DELAY
    CONFIG_LOW_PASS_FILTER = _mscl.ConfigIssue_CONFIG_LOW_PASS_FILTER
    CONFIG_DATA_MODE = _mscl.ConfigIssue_CONFIG_DATA_MODE
    CONFIG_DERIVED_DATA_RATE = _mscl.ConfigIssue_CONFIG_DERIVED_DATA_RATE
    CONFIG_DERIVED_MASK_RMS = _mscl.ConfigIssue_CONFIG_DERIVED_MASK_RMS
    CONFIG_DERIVED_MASK_P2P = _mscl.ConfigIssue_CONFIG_DERIVED_MASK_P2P
    CONFIG_DERIVED_MASK_IPS = _mscl.ConfigIssue_CONFIG_DERIVED_MASK_IPS
    CONFIG_DERIVED_MASK_CREST_FACTOR = _mscl.ConfigIssue_CONFIG_DERIVED_MASK_CREST_FACTOR
    CONFIG_HIGH_PASS_FILTER = _mscl.ConfigIssue_CONFIG_HIGH_PASS_FILTER
    CONFIG_DERIVED_MASK = _mscl.ConfigIssue_CONFIG_DERIVED_MASK
    CONFIG_COMM_PROTOCOL = _mscl.ConfigIssue_CONFIG_COMM_PROTOCOL
    CONFIG_DERIVED_MASK_MEAN = _mscl.ConfigIssue_CONFIG_DERIVED_MASK_MEAN
    CONFIG_GAUGE_RESISTANCE = _mscl.ConfigIssue_CONFIG_GAUGE_RESISTANCE
    CONFIG_NUM_ACTIVE_GAUGES = _mscl.ConfigIssue_CONFIG_NUM_ACTIVE_GAUGES
    CONFIG_TEMP_SENSOR_OPTS = _mscl.ConfigIssue_CONFIG_TEMP_SENSOR_OPTS
    CONFIG_DEBOUNCE_FILTER = _mscl.ConfigIssue_CONFIG_DEBOUNCE_FILTER
    CONFIG_PULLUP_RESISTOR = _mscl.ConfigIssue_CONFIG_PULLUP_RESISTOR
    CONFIG_EXCITATION_VOLTAGE = _mscl.ConfigIssue_CONFIG_EXCITATION_VOLTAGE
    CONFIG_DERIVED_UNIT = _mscl.ConfigIssue_CONFIG_DERIVED_UNIT
    CONFIG_SENSOR_OUTPUT_MODE = _mscl.ConfigIssue_CONFIG_SENSOR_OUTPUT_MODE

    def __init__(self, *args):
        this = _mscl.new_ConfigIssue(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def id(self):
        return _mscl.ConfigIssue_id(self)

    def description(self):
        return _mscl.ConfigIssue_description(self)

    def isChannelGroupIssue(self):
        return _mscl.ConfigIssue_isChannelGroupIssue(self)

    def channelMask(self):
        return _mscl.ConfigIssue_channelMask(self)
    __swig_destroy__ = _mscl.delete_ConfigIssue
    __del__ = lambda self: None
ConfigIssue_swigregister = _mscl.ConfigIssue_swigregister
ConfigIssue_swigregister(ConfigIssue)

class ActivitySense(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_ActivitySense()
        try:
            self.this.append(this)
        except:
            self.this = this

    def enabled(self, *args):
        return _mscl.ActivitySense_enabled(self, *args)

    def activityThreshold(self, *args):
        return _mscl.ActivitySense_activityThreshold(self, *args)

    def inactivityThreshold(self, *args):
        return _mscl.ActivitySense_inactivityThreshold(self, *args)

    def activityTime(self, *args):
        return _mscl.ActivitySense_activityTime(self, *args)

    def inactivityTimeout(self, *args):
        return _mscl.ActivitySense_inactivityTimeout(self, *args)
    __swig_destroy__ = _mscl.delete_ActivitySense
    __del__ = lambda self: None
ActivitySense_swigregister = _mscl.ActivitySense_swigregister
ActivitySense_swigregister(ActivitySense)

class Trigger(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Trigger(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def channelNumber(self, *args):
        return _mscl.Trigger_channelNumber(self, *args)

    def triggerType(self, *args):
        return _mscl.Trigger_triggerType(self, *args)

    def triggerValue(self, *args):
        return _mscl.Trigger_triggerValue(self, *args)
    __swig_destroy__ = _mscl.delete_Trigger
    __del__ = lambda self: None
Trigger_swigregister = _mscl.Trigger_swigregister
Trigger_swigregister(Trigger)

class EventTriggerOptions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_EventTriggerOptions()
        try:
            self.this.append(this)
        except:
            self.this = this

    def triggerMask(self, *args):
        return _mscl.EventTriggerOptions_triggerMask(self, *args)

    def anyTriggersEnabled(self):
        return _mscl.EventTriggerOptions_anyTriggersEnabled(self)

    def triggerEnabled(self, triggerIndex):
        return _mscl.EventTriggerOptions_triggerEnabled(self, triggerIndex)

    def enableTrigger(self, triggerIndex, enable=True):
        return _mscl.EventTriggerOptions_enableTrigger(self, triggerIndex, enable)

    def preDuration(self, *args):
        return _mscl.EventTriggerOptions_preDuration(self, *args)

    def postDuration(self, *args):
        return _mscl.EventTriggerOptions_postDuration(self, *args)

    def trigger(self, *args):
        return _mscl.EventTriggerOptions_trigger(self, *args)

    def triggers(self):
        return _mscl.EventTriggerOptions_triggers(self)
    __swig_destroy__ = _mscl.delete_EventTriggerOptions
    __del__ = lambda self: None
EventTriggerOptions_swigregister = _mscl.EventTriggerOptions_swigregister
EventTriggerOptions_swigregister(EventTriggerOptions)

class SnCurveSegment(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_SnCurveSegment(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def m(self, *args):
        return _mscl.SnCurveSegment_m(self, *args)

    def logA(self, *args):
        return _mscl.SnCurveSegment_logA(self, *args)
    __swig_destroy__ = _mscl.delete_SnCurveSegment
    __del__ = lambda self: None
SnCurveSegment_swigregister = _mscl.SnCurveSegment_swigregister
SnCurveSegment_swigregister(SnCurveSegment)

class FatigueOptions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_FatigueOptions()
        try:
            self.this.append(this)
        except:
            self.this = this

    def youngsModulus(self, *args):
        return _mscl.FatigueOptions_youngsModulus(self, *args)

    def poissonsRatio(self, *args):
        return _mscl.FatigueOptions_poissonsRatio(self, *args)

    def peakValleyThreshold(self, *args):
        return _mscl.FatigueOptions_peakValleyThreshold(self, *args)

    def debugMode(self, *args):
        return _mscl.FatigueOptions_debugMode(self, *args)

    def damageAngles(self):
        return _mscl.FatigueOptions_damageAngles(self)

    def damageAngle(self, *args):
        return _mscl.FatigueOptions_damageAngle(self, *args)

    def snCurveSegments(self):
        return _mscl.FatigueOptions_snCurveSegments(self)

    def snCurveSegment(self, *args):
        return _mscl.FatigueOptions_snCurveSegment(self, *args)

    def fatigueMode(self, *args):
        return _mscl.FatigueOptions_fatigueMode(self, *args)

    def distributedAngleMode_numAngles(self, *args):
        return _mscl.FatigueOptions_distributedAngleMode_numAngles(self, *args)

    def distributedAngleMode_lowerBound(self, *args):
        return _mscl.FatigueOptions_distributedAngleMode_lowerBound(self, *args)

    def distributedAngleMode_upperBound(self, *args):
        return _mscl.FatigueOptions_distributedAngleMode_upperBound(self, *args)

    def histogramEnable(self, *args):
        return _mscl.FatigueOptions_histogramEnable(self, *args)
    __swig_destroy__ = _mscl.delete_FatigueOptions
    __del__ = lambda self: None
FatigueOptions_swigregister = _mscl.FatigueOptions_swigregister
FatigueOptions_swigregister(FatigueOptions)

class HistogramOptions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_HistogramOptions()
        try:
            self.this.append(this)
        except:
            self.this = this

    def transmitRate(self, *args):
        return _mscl.HistogramOptions_transmitRate(self, *args)

    def binsStart(self, *args):
        return _mscl.HistogramOptions_binsStart(self, *args)

    def binsSize(self, *args):
        return _mscl.HistogramOptions_binsSize(self, *args)
    __swig_destroy__ = _mscl.delete_HistogramOptions
    __del__ = lambda self: None
HistogramOptions_swigregister = _mscl.HistogramOptions_swigregister
HistogramOptions_swigregister(HistogramOptions)

class InputRangeEntry(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    inputRange = _swig_property(_mscl.InputRangeEntry_inputRange_get, _mscl.InputRangeEntry_inputRange_set)
    hasGain = _swig_property(_mscl.InputRangeEntry_hasGain_get, _mscl.InputRangeEntry_hasGain_set)
    gain = _swig_property(_mscl.InputRangeEntry_gain_get, _mscl.InputRangeEntry_gain_set)

    def __init__(self, *args):
        this = _mscl.new_InputRangeEntry(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_InputRangeEntry
    __del__ = lambda self: None
InputRangeEntry_swigregister = _mscl.InputRangeEntry_swigregister
InputRangeEntry_swigregister(InputRangeEntry)

class TempSensorOptions(object):
    thisown = _swig_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
    Thermocouple = staticmethod(_mscl.TempSensorOptions_Thermocouple)
    RTD = staticmethod(_mscl.TempSensorOptions_RTD)
    Thermistor = staticmethod(_mscl.TempSensorOptions_Thermistor)

    def transducerType(self):
        return _mscl.TempSensorOptions_transducerType(self)

    def thermocoupleType(self):
        return _mscl.TempSensorOptions_thermocoupleType(self)

    def rtdType(self):
        return _mscl.TempSensorOptions_rtdType(self)

    def rtdWireType(self):
        return _mscl.TempSensorOptions_rtdWireType(self)

    def thermistorType(self):
        return _mscl.TempSensorOptions_thermistorType(self)
    __swig_destroy__ = _mscl.delete_TempSensorOptions
    __del__ = lambda self: None
TempSensorOptions_swigregister = _mscl.TempSensorOptions_swigregister
TempSensorOptions_swigregister(TempSensorOptions)

def TempSensorOptions_Thermocouple(thermocouple):
    return _mscl.TempSensorOptions_Thermocouple(thermocouple)
TempSensorOptions_Thermocouple = _mscl.TempSensorOptions_Thermocouple

def TempSensorOptions_RTD(wire, rtd):
    return _mscl.TempSensorOptions_RTD(wire, rtd)
TempSensorOptions_RTD = _mscl.TempSensorOptions_RTD

def TempSensorOptions_Thermistor(thermistor):
    return _mscl.TempSensorOptions_Thermistor(thermistor)
TempSensorOptions_Thermistor = _mscl.TempSensorOptions_Thermistor

class WirelessModels(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    node_vLink_legacy = _mscl.WirelessModels_node_vLink_legacy
    node_cfBearingTempLink = _mscl.WirelessModels_node_cfBearingTempLink
    node_envLink_pro = _mscl.WirelessModels_node_envLink_pro
    node_gLink_2g = _mscl.WirelessModels_node_gLink_2g
    node_gLink_10g = _mscl.WirelessModels_node_gLink_10g
    node_gLinkII_cust_in = _mscl.WirelessModels_node_gLinkII_cust_in
    node_gLinkII_2g_in = _mscl.WirelessModels_node_gLinkII_2g_in
    node_gLinkII_10g_in = _mscl.WirelessModels_node_gLinkII_10g_in
    node_gLinkII_cust_ex = _mscl.WirelessModels_node_gLinkII_cust_ex
    node_gLinkII_2g_ex = _mscl.WirelessModels_node_gLinkII_2g_ex
    node_gLinkII_10g_ex = _mscl.WirelessModels_node_gLinkII_10g_ex
    node_gLink_rgd_10g = _mscl.WirelessModels_node_gLink_rgd_10g
    node_gLink_200_8g = _mscl.WirelessModels_node_gLink_200_8g
    node_gLink_200_40g = _mscl.WirelessModels_node_gLink_200_40g
    node_gLink_200_8g_oem = _mscl.WirelessModels_node_gLink_200_8g_oem
    node_gLink_200_40g_oem = _mscl.WirelessModels_node_gLink_200_40g_oem
    node_gLink_200_8g_oem_mmcx = _mscl.WirelessModels_node_gLink_200_8g_oem_mmcx
    node_gLink_200_40g_oem_mmcx = _mscl.WirelessModels_node_gLink_200_40g_oem_mmcx
    node_gLink_200_8g_oem_u_fl = _mscl.WirelessModels_node_gLink_200_8g_oem_u_fl
    node_gLink_200_40g_oem_u_fl = _mscl.WirelessModels_node_gLink_200_40g_oem_u_fl
    node_sgLink_oem_S = _mscl.WirelessModels_node_sgLink_oem_S
    node_sgLink = _mscl.WirelessModels_node_sgLink
    node_sgLink_oem = _mscl.WirelessModels_node_sgLink_oem
    node_sgLink_micro = _mscl.WirelessModels_node_sgLink_micro
    node_sgLink200_oem = _mscl.WirelessModels_node_sgLink200_oem
    node_sgLink200_oem_ufl = _mscl.WirelessModels_node_sgLink200_oem_ufl
    node_sgLink200_oem_hbridge_1K = _mscl.WirelessModels_node_sgLink200_oem_hbridge_1K
    node_sgLink200_oem_hbridge_1K_ufl = _mscl.WirelessModels_node_sgLink200_oem_hbridge_1K_ufl
    node_sgLink200_oem_hbridge_120 = _mscl.WirelessModels_node_sgLink200_oem_hbridge_120
    node_sgLink200_oem_hbridge_120_ufl = _mscl.WirelessModels_node_sgLink200_oem_hbridge_120_ufl
    node_sgLink200_oem_hbridge_350 = _mscl.WirelessModels_node_sgLink200_oem_hbridge_350
    node_sgLink200_oem_hbridge_350_ufl = _mscl.WirelessModels_node_sgLink200_oem_hbridge_350_ufl
    node_sgLink200_oem_qbridge_1K = _mscl.WirelessModels_node_sgLink200_oem_qbridge_1K
    node_sgLink200_oem_qbridge_1K_ufl = _mscl.WirelessModels_node_sgLink200_oem_qbridge_1K_ufl
    node_sgLink200_oem_qbridge_120 = _mscl.WirelessModels_node_sgLink200_oem_qbridge_120
    node_sgLink200_oem_qbridge_120_ufl = _mscl.WirelessModels_node_sgLink200_oem_qbridge_120_ufl
    node_sgLink200_oem_qbridge_350 = _mscl.WirelessModels_node_sgLink200_oem_qbridge_350
    node_sgLink200_oem_qbridge_350_ufl = _mscl.WirelessModels_node_sgLink200_oem_qbridge_350_ufl
    node_sgLink_rgd = _mscl.WirelessModels_node_sgLink_rgd
    node_shmLink = _mscl.WirelessModels_node_shmLink
    node_tcLink_1ch = _mscl.WirelessModels_node_tcLink_1ch
    node_tcLink_6ch = _mscl.WirelessModels_node_tcLink_6ch
    node_tcLink_3ch = _mscl.WirelessModels_node_tcLink_3ch
    node_tcLink_6ch_ip67 = _mscl.WirelessModels_node_tcLink_6ch_ip67
    node_tcLink200_oem = _mscl.WirelessModels_node_tcLink200_oem
    node_tcLink200_oem_ufl = _mscl.WirelessModels_node_tcLink200_oem_ufl
    node_tcLink_6ch_ip67_rht = _mscl.WirelessModels_node_tcLink_6ch_ip67_rht
    node_vLink = _mscl.WirelessModels_node_vLink
    node_vLink200 = _mscl.WirelessModels_node_vLink200
    node_vLink200_qbridge_1K = _mscl.WirelessModels_node_vLink200_qbridge_1K
    node_vLink200_qbridge_120 = _mscl.WirelessModels_node_vLink200_qbridge_120
    node_vLink200_qbridge_350 = _mscl.WirelessModels_node_vLink200_qbridge_350
    node_vLink200_hbridge_1K = _mscl.WirelessModels_node_vLink200_hbridge_1K
    node_vLink200_hbridge_120 = _mscl.WirelessModels_node_vLink200_hbridge_120
    node_vLink200_hbridge_350 = _mscl.WirelessModels_node_vLink200_hbridge_350
    node_iepeLink = _mscl.WirelessModels_node_iepeLink
    node_dvrtLink = _mscl.WirelessModels_node_dvrtLink
    node_envLink_mini = _mscl.WirelessModels_node_envLink_mini
    node_wattLink = _mscl.WirelessModels_node_wattLink
    node_wattLink_3Y208 = _mscl.WirelessModels_node_wattLink_3Y208
    node_wattLink_3D240 = _mscl.WirelessModels_node_wattLink_3D240
    node_wattLink_3Y400 = _mscl.WirelessModels_node_wattLink_3Y400
    node_wattLink_3D400 = _mscl.WirelessModels_node_wattLink_3D400
    node_wattLink_3Y480 = _mscl.WirelessModels_node_wattLink_3Y480
    node_wattLink_3D480 = _mscl.WirelessModels_node_wattLink_3D480
    node_wattLink_3Y600 = _mscl.WirelessModels_node_wattLink_3Y600
    node_mvPerVLink = _mscl.WirelessModels_node_mvPerVLink
    node_rtdLink = _mscl.WirelessModels_node_rtdLink
    node_shmLink2_cust1_oldNumber = _mscl.WirelessModels_node_shmLink2_cust1_oldNumber
    node_shmLink2_cust1 = _mscl.WirelessModels_node_shmLink2_cust1
    node_shmLink200 = _mscl.WirelessModels_node_shmLink200
    node_shmLink201 = _mscl.WirelessModels_node_shmLink201
    node_shmLink201_qbridge_1K = _mscl.WirelessModels_node_shmLink201_qbridge_1K
    node_shmLink201_qbridge_348 = _mscl.WirelessModels_node_shmLink201_qbridge_348
    node_shmLink201_hbridge_1K = _mscl.WirelessModels_node_shmLink201_hbridge_1K
    node_shmLink201_hbridge_348 = _mscl.WirelessModels_node_shmLink201_hbridge_348
    node_shmLink201_fullbridge = _mscl.WirelessModels_node_shmLink201_fullbridge
    node_torqueLink = _mscl.WirelessModels_node_torqueLink
    node_torqueLink200 = _mscl.WirelessModels_node_torqueLink200
    node_sgLink_herm = _mscl.WirelessModels_node_sgLink_herm
    node_sgLink_herm_2600 = _mscl.WirelessModels_node_sgLink_herm_2600
    node_sgLink_herm_2700 = _mscl.WirelessModels_node_sgLink_herm_2700
    node_sgLink_herm_2800 = _mscl.WirelessModels_node_sgLink_herm_2800
    node_wirelessImpactSensor = _mscl.WirelessModels_node_wirelessImpactSensor
    base_wsda_1000 = _mscl.WirelessModels_base_wsda_1000
    base_wsda_1500 = _mscl.WirelessModels_base_wsda_1500
    base_wsda_2000 = _mscl.WirelessModels_base_wsda_2000
    base_wsdaBase_200_legacy = _mscl.WirelessModels_base_wsdaBase_200_legacy
    base_wsdaBase_200 = _mscl.WirelessModels_base_wsdaBase_200
    base_wsdaBase_200_extAntenna = _mscl.WirelessModels_base_wsdaBase_200_extAntenna
    base_wsdaBase_101_analog = _mscl.WirelessModels_base_wsdaBase_101_analog
    base_wsdaBase_102_rs232 = _mscl.WirelessModels_base_wsdaBase_102_rs232
    base_wsdaBase_104_usb = _mscl.WirelessModels_base_wsdaBase_104_usb
    base_wsi_104 = _mscl.WirelessModels_base_wsi_104
    base_wsdaBase_mini = _mscl.WirelessModels_base_wsdaBase_mini

    def __init__(self):
        this = _mscl.new_WirelessModels()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_WirelessModels
    __del__ = lambda self: None
WirelessModels_swigregister = _mscl.WirelessModels_swigregister
WirelessModels_swigregister(WirelessModels)

class NodeDiscovery(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def nodeAddress(self):
        return _mscl.NodeDiscovery_nodeAddress(self)

    def frequency(self):
        return _mscl.NodeDiscovery_frequency(self)

    def panId(self):
        return _mscl.NodeDiscovery_panId(self)

    def model(self):
        return _mscl.NodeDiscovery_model(self)

    def serialNumber(self):
        return _mscl.NodeDiscovery_serialNumber(self)

    def firmwareVersion(self):
        return _mscl.NodeDiscovery_firmwareVersion(self)

    def defaultMode(self):
        return _mscl.NodeDiscovery_defaultMode(self)

    def builtInTestResult(self):
        return _mscl.NodeDiscovery_builtInTestResult(self)

    def communicationProtocol(self):
        return _mscl.NodeDiscovery_communicationProtocol(self)

    def asppVersion_lxrs(self):
        return _mscl.NodeDiscovery_asppVersion_lxrs(self)

    def asppVersion_lxrsPlus(self):
        return _mscl.NodeDiscovery_asppVersion_lxrsPlus(self)

    def baseRssi(self):
        return _mscl.NodeDiscovery_baseRssi(self)

    def timestamp(self):
        return _mscl.NodeDiscovery_timestamp(self)

    def __init__(self):
        this = _mscl.new_NodeDiscovery()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_NodeDiscovery
    __del__ = lambda self: None
NodeDiscovery_swigregister = _mscl.NodeDiscovery_swigregister
NodeDiscovery_swigregister(NodeDiscovery)

class LinearEquation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_LinearEquation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def slope(self, *args):
        return _mscl.LinearEquation_slope(self, *args)

    def offset(self, *args):
        return _mscl.LinearEquation_offset(self, *args)
    __swig_destroy__ = _mscl.delete_LinearEquation
    __del__ = lambda self: None
LinearEquation_swigregister = _mscl.LinearEquation_swigregister
LinearEquation_swigregister(LinearEquation)

class CalCoefficients(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_CalCoefficients(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def equationType(self):
        return _mscl.CalCoefficients_equationType(self)

    def unit(self):
        return _mscl.CalCoefficients_unit(self)

    def linearEquation(self):
        return _mscl.CalCoefficients_linearEquation(self)
    __swig_destroy__ = _mscl.delete_CalCoefficients
    __del__ = lambda self: None
CalCoefficients_swigregister = _mscl.CalCoefficients_swigregister
CalCoefficients_swigregister(CalCoefficients)

class ChannelGroup(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_ChannelGroup()
        try:
            self.this.append(this)
        except:
            self.this = this

    def channels(self):
        return _mscl.ChannelGroup_channels(self)

    def name(self):
        return _mscl.ChannelGroup_name(self)

    def eepromLocation(self, setting):
        return _mscl.ChannelGroup_eepromLocation(self, setting)

    def settings(self):
        return _mscl.ChannelGroup_settings(self)

    def hasSetting(self, setting):
        return _mscl.ChannelGroup_hasSetting(self, setting)

    def hasSettingAndChannel(self, setting, channelNumber):
        return _mscl.ChannelGroup_hasSettingAndChannel(self, setting, channelNumber)
    __swig_destroy__ = _mscl.delete_ChannelGroup
    __del__ = lambda self: None
ChannelGroup_swigregister = _mscl.ChannelGroup_swigregister
ChannelGroup_swigregister(ChannelGroup)

class WirelessChannel(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    channel_unknown = _mscl.WirelessChannel_channel_unknown
    channel_1 = _mscl.WirelessChannel_channel_1
    channel_2 = _mscl.WirelessChannel_channel_2
    channel_3 = _mscl.WirelessChannel_channel_3
    channel_4 = _mscl.WirelessChannel_channel_4
    channel_5 = _mscl.WirelessChannel_channel_5
    channel_6 = _mscl.WirelessChannel_channel_6
    channel_7 = _mscl.WirelessChannel_channel_7
    channel_8 = _mscl.WirelessChannel_channel_8
    channel_9 = _mscl.WirelessChannel_channel_9
    channel_10 = _mscl.WirelessChannel_channel_10
    channel_11 = _mscl.WirelessChannel_channel_11
    channel_12 = _mscl.WirelessChannel_channel_12
    channel_13 = _mscl.WirelessChannel_channel_13
    channel_14 = _mscl.WirelessChannel_channel_14
    channel_15 = _mscl.WirelessChannel_channel_15
    channel_16 = _mscl.WirelessChannel_channel_16
    channel_digital_1 = _mscl.WirelessChannel_channel_digital_1
    channel_digital_2 = _mscl.WirelessChannel_channel_digital_2
    channel_digital_3 = _mscl.WirelessChannel_channel_digital_3
    channel_digital_4 = _mscl.WirelessChannel_channel_digital_4
    channel_digital_5 = _mscl.WirelessChannel_channel_digital_5
    channel_digital_6 = _mscl.WirelessChannel_channel_digital_6
    channel_digital_7 = _mscl.WirelessChannel_channel_digital_7
    channel_digital_8 = _mscl.WirelessChannel_channel_digital_8
    channel_digital_9 = _mscl.WirelessChannel_channel_digital_9
    channel_digital_10 = _mscl.WirelessChannel_channel_digital_10
    channel_digital_11 = _mscl.WirelessChannel_channel_digital_11
    channel_digital_12 = _mscl.WirelessChannel_channel_digital_12
    channel_digital_13 = _mscl.WirelessChannel_channel_digital_13
    channel_digital_14 = _mscl.WirelessChannel_channel_digital_14
    channel_digital_15 = _mscl.WirelessChannel_channel_digital_15
    channel_digital_16 = _mscl.WirelessChannel_channel_digital_16
    channel_structuralHealth = _mscl.WirelessChannel_channel_structuralHealth
    channel_hcl_rawBase_mag1_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag1_x
    channel_hcl_rawBase_mag1_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag1_y
    channel_hcl_rawBase_mag1_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag1_z
    channel_hcl_rawBase_mag2_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag2_x
    channel_hcl_rawBase_mag2_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag2_y
    channel_hcl_rawBase_mag2_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag2_z
    channel_hcl_rawBase_mag3_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag3_x
    channel_hcl_rawBase_mag3_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag3_y
    channel_hcl_rawBase_mag3_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag3_z
    channel_hcl_rawBase_mag4_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag4_x
    channel_hcl_rawBase_mag4_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag4_y
    channel_hcl_rawBase_mag4_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag4_z
    channel_hcl_rawBase_mag5_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag5_x
    channel_hcl_rawBase_mag5_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag5_y
    channel_hcl_rawBase_mag5_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag5_z
    channel_hcl_rawBase_mag6_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag6_x
    channel_hcl_rawBase_mag6_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag6_y
    channel_hcl_rawBase_mag6_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag6_z
    channel_hcl_rawBase_mag7_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag7_x
    channel_hcl_rawBase_mag7_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag7_y
    channel_hcl_rawBase_mag7_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag7_z
    channel_hcl_rawBase_mag8_x = _mscl.WirelessChannel_channel_hcl_rawBase_mag8_x
    channel_hcl_rawBase_mag8_y = _mscl.WirelessChannel_channel_hcl_rawBase_mag8_y
    channel_hcl_rawBase_mag8_z = _mscl.WirelessChannel_channel_hcl_rawBase_mag8_z
    channel_hcl_rawBase_gyro_x = _mscl.WirelessChannel_channel_hcl_rawBase_gyro_x
    channel_hcl_rawBase_gyro_y = _mscl.WirelessChannel_channel_hcl_rawBase_gyro_y
    channel_hcl_rawBase_gyro_z = _mscl.WirelessChannel_channel_hcl_rawBase_gyro_z
    channel_error_code = _mscl.WirelessChannel_channel_error_code
    channel_hcl_rawStrain_BL30 = _mscl.WirelessChannel_channel_hcl_rawStrain_BL30
    channel_hcl_rawStrain_BL120 = _mscl.WirelessChannel_channel_hcl_rawStrain_BL120
    channel_hcl_rawStrain_A60 = _mscl.WirelessChannel_channel_hcl_rawStrain_A60
    channel_hcl_rawStrain_A150 = _mscl.WirelessChannel_channel_hcl_rawStrain_A150
    channel_hcl_rawStrain_AL30 = _mscl.WirelessChannel_channel_hcl_rawStrain_AL30
    channel_hcl_rawStrain_AL120 = _mscl.WirelessChannel_channel_hcl_rawStrain_AL120
    channel_hcl_rawStrain_BR60 = _mscl.WirelessChannel_channel_hcl_rawStrain_BR60
    channel_hcl_rawStrain_BR150 = _mscl.WirelessChannel_channel_hcl_rawStrain_BR150
    channel_hcl_rawStrain_B30 = _mscl.WirelessChannel_channel_hcl_rawStrain_B30
    channel_hcl_rawStrain_T120 = _mscl.WirelessChannel_channel_hcl_rawStrain_T120
    channel_hcl_rawStrain_AR60 = _mscl.WirelessChannel_channel_hcl_rawStrain_AR60
    channel_hcl_rawStrain_AR150 = _mscl.WirelessChannel_channel_hcl_rawStrain_AR150
    channel_hcl_rawStrain_A30 = _mscl.WirelessChannel_channel_hcl_rawStrain_A30
    channel_hcl_rawStrain_A120 = _mscl.WirelessChannel_channel_hcl_rawStrain_A120
    channel_hcl_rawStrain_BL90 = _mscl.WirelessChannel_channel_hcl_rawStrain_BL90
    channel_hcl_rawStrain_BL180 = _mscl.WirelessChannel_channel_hcl_rawStrain_BL180
    channel_hcl_rawStrain_BR30 = _mscl.WirelessChannel_channel_hcl_rawStrain_BR30
    channel_hcl_rawStrain_BR120 = _mscl.WirelessChannel_channel_hcl_rawStrain_BR120
    channel_hcl_rawStrain_AL90 = _mscl.WirelessChannel_channel_hcl_rawStrain_AL90
    channel_hcl_rawStrain_AL180 = _mscl.WirelessChannel_channel_hcl_rawStrain_AL180
    channel_hcl_rawStrain_AR30 = _mscl.WirelessChannel_channel_hcl_rawStrain_AR30
    channel_hcl_rawStrain_AR120 = _mscl.WirelessChannel_channel_hcl_rawStrain_AR120
    channel_hcl_rawStrain_B90 = _mscl.WirelessChannel_channel_hcl_rawStrain_B90
    channel_hcl_rawStrain_T0 = _mscl.WirelessChannel_channel_hcl_rawStrain_T0
    channel_hcl_rawStrain_BL60 = _mscl.WirelessChannel_channel_hcl_rawStrain_BL60
    channel_hcl_rawStrain_BL150 = _mscl.WirelessChannel_channel_hcl_rawStrain_BL150
    channel_hcl_rawStrain_A90 = _mscl.WirelessChannel_channel_hcl_rawStrain_A90
    channel_hcl_rawStrain_A0 = _mscl.WirelessChannel_channel_hcl_rawStrain_A0
    channel_hcl_rawStrain_AL60 = _mscl.WirelessChannel_channel_hcl_rawStrain_AL60
    channel_hcl_rawStrain_AL150 = _mscl.WirelessChannel_channel_hcl_rawStrain_AL150
    channel_hcl_rawStrain_BR90 = _mscl.WirelessChannel_channel_hcl_rawStrain_BR90
    channel_hcl_rawStrain_BR0 = _mscl.WirelessChannel_channel_hcl_rawStrain_BR0
    channel_hcl_rawStrain_T60 = _mscl.WirelessChannel_channel_hcl_rawStrain_T60
    channel_hcl_rawStrain_B150 = _mscl.WirelessChannel_channel_hcl_rawStrain_B150
    channel_hcl_rawStrain_AR90 = _mscl.WirelessChannel_channel_hcl_rawStrain_AR90
    channel_hcl_rawStrain_AR0 = _mscl.WirelessChannel_channel_hcl_rawStrain_AR0
    channel_hcl_rawInertial_accel1 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel1
    channel_hcl_rawInertial_accel2 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel2
    channel_hcl_rawInertial_accel3 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel3
    channel_hcl_rawInertial_accel4 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel4
    channel_hcl_rawInertial_accel5 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel5
    channel_hcl_rawInertial_accel6 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel6
    channel_hcl_rawInertial_accel7 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel7
    channel_hcl_rawInertial_accel8 = _mscl.WirelessChannel_channel_hcl_rawInertial_accel8
    channel_hcl_rawInertial_gyroX = _mscl.WirelessChannel_channel_hcl_rawInertial_gyroX
    channel_hcl_rawInertial_gyroY = _mscl.WirelessChannel_channel_hcl_rawInertial_gyroY
    channel_hcl_rawInertial_gyroZ = _mscl.WirelessChannel_channel_hcl_rawInertial_gyroZ
    channel_rawAngleStrain = _mscl.WirelessChannel_channel_rawAngleStrain
    channel_beaconEcho = _mscl.WirelessChannel_channel_beaconEcho
    channel_rfSweep = _mscl.WirelessChannel_channel_rfSweep
    channel_diag_state = _mscl.WirelessChannel_channel_diag_state
    channel_diag_runtime_idle = _mscl.WirelessChannel_channel_diag_runtime_idle
    channel_diag_runtime_sleep = _mscl.WirelessChannel_channel_diag_runtime_sleep
    channel_diag_runtime_activeRun = _mscl.WirelessChannel_channel_diag_runtime_activeRun
    channel_diag_runtime_inactiveRun = _mscl.WirelessChannel_channel_diag_runtime_inactiveRun
    channel_diag_resetCounter = _mscl.WirelessChannel_channel_diag_resetCounter
    channel_diag_lowBatteryFlag = _mscl.WirelessChannel_channel_diag_lowBatteryFlag
    channel_diag_sweepIndex = _mscl.WirelessChannel_channel_diag_sweepIndex
    channel_diag_badSweepCount = _mscl.WirelessChannel_channel_diag_badSweepCount
    channel_diag_totalTx = _mscl.WirelessChannel_channel_diag_totalTx
    channel_diag_totalReTx = _mscl.WirelessChannel_channel_diag_totalReTx
    channel_diag_totalDroppedPackets = _mscl.WirelessChannel_channel_diag_totalDroppedPackets
    channel_diag_builtInTestResult = _mscl.WirelessChannel_channel_diag_builtInTestResult
    channel_diag_eventIndex = _mscl.WirelessChannel_channel_diag_eventIndex
    channel_hcl_axialLoadX = _mscl.WirelessChannel_channel_hcl_axialLoadX
    channel_hcl_axialLoadY = _mscl.WirelessChannel_channel_hcl_axialLoadY
    channel_hcl_axialLoadZ = _mscl.WirelessChannel_channel_hcl_axialLoadZ
    channel_hcl_bendingMomentFlap = _mscl.WirelessChannel_channel_hcl_bendingMomentFlap
    channel_hcl_bendingMomentLag = _mscl.WirelessChannel_channel_hcl_bendingMomentLag
    channel_hcl_bendingMomentPitch = _mscl.WirelessChannel_channel_hcl_bendingMomentPitch
    channel_hcl_motionFlap_mag = _mscl.WirelessChannel_channel_hcl_motionFlap_mag
    channel_hcl_motionLag_mag = _mscl.WirelessChannel_channel_hcl_motionLag_mag
    channel_hcl_motionPitch_mag = _mscl.WirelessChannel_channel_hcl_motionPitch_mag
    channel_hcl_motionFlap_inertial = _mscl.WirelessChannel_channel_hcl_motionFlap_inertial
    channel_hcl_motionLag_inertial = _mscl.WirelessChannel_channel_hcl_motionLag_inertial
    channel_hcl_motionPitch_inertial = _mscl.WirelessChannel_channel_hcl_motionPitch_inertial
    channel_hcl_cockingStiffness_mag = _mscl.WirelessChannel_channel_hcl_cockingStiffness_mag
    channel_hcl_cockingStiffness_inertial = _mscl.WirelessChannel_channel_hcl_cockingStiffness_inertial
    channel_hcl_temperature = _mscl.WirelessChannel_channel_hcl_temperature
    channel_diag_externalPower = _mscl.WirelessChannel_channel_diag_externalPower
    channel_diag_internalTemp = _mscl.WirelessChannel_channel_diag_internalTemp
    channel_1_rms = _mscl.WirelessChannel_channel_1_rms
    channel_2_rms = _mscl.WirelessChannel_channel_2_rms
    channel_3_rms = _mscl.WirelessChannel_channel_3_rms
    channel_4_rms = _mscl.WirelessChannel_channel_4_rms
    channel_5_rms = _mscl.WirelessChannel_channel_5_rms
    channel_6_rms = _mscl.WirelessChannel_channel_6_rms
    channel_7_rms = _mscl.WirelessChannel_channel_7_rms
    channel_8_rms = _mscl.WirelessChannel_channel_8_rms
    channel_9_rms = _mscl.WirelessChannel_channel_9_rms
    channel_10_rms = _mscl.WirelessChannel_channel_10_rms
    channel_11_rms = _mscl.WirelessChannel_channel_11_rms
    channel_12_rms = _mscl.WirelessChannel_channel_12_rms
    channel_13_rms = _mscl.WirelessChannel_channel_13_rms
    channel_14_rms = _mscl.WirelessChannel_channel_14_rms
    channel_15_rms = _mscl.WirelessChannel_channel_15_rms
    channel_16_rms = _mscl.WirelessChannel_channel_16_rms
    channel_1_peakToPeak = _mscl.WirelessChannel_channel_1_peakToPeak
    channel_2_peakToPeak = _mscl.WirelessChannel_channel_2_peakToPeak
    channel_3_peakToPeak = _mscl.WirelessChannel_channel_3_peakToPeak
    channel_4_peakToPeak = _mscl.WirelessChannel_channel_4_peakToPeak
    channel_5_peakToPeak = _mscl.WirelessChannel_channel_5_peakToPeak
    channel_6_peakToPeak = _mscl.WirelessChannel_channel_6_peakToPeak
    channel_7_peakToPeak = _mscl.WirelessChannel_channel_7_peakToPeak
    channel_8_peakToPeak = _mscl.WirelessChannel_channel_8_peakToPeak
    channel_9_peakToPeak = _mscl.WirelessChannel_channel_9_peakToPeak
    channel_10_peakToPeak = _mscl.WirelessChannel_channel_10_peakToPeak
    channel_11_peakToPeak = _mscl.WirelessChannel_channel_11_peakToPeak
    channel_12_peakToPeak = _mscl.WirelessChannel_channel_12_peakToPeak
    channel_13_peakToPeak = _mscl.WirelessChannel_channel_13_peakToPeak
    channel_14_peakToPeak = _mscl.WirelessChannel_channel_14_peakToPeak
    channel_15_peakToPeak = _mscl.WirelessChannel_channel_15_peakToPeak
    channel_16_peakToPeak = _mscl.WirelessChannel_channel_16_peakToPeak
    channel_1_ips = _mscl.WirelessChannel_channel_1_ips
    channel_2_ips = _mscl.WirelessChannel_channel_2_ips
    channel_3_ips = _mscl.WirelessChannel_channel_3_ips
    channel_4_ips = _mscl.WirelessChannel_channel_4_ips
    channel_5_ips = _mscl.WirelessChannel_channel_5_ips
    channel_6_ips = _mscl.WirelessChannel_channel_6_ips
    channel_7_ips = _mscl.WirelessChannel_channel_7_ips
    channel_8_ips = _mscl.WirelessChannel_channel_8_ips
    channel_9_ips = _mscl.WirelessChannel_channel_9_ips
    channel_10_ips = _mscl.WirelessChannel_channel_10_ips
    channel_11_ips = _mscl.WirelessChannel_channel_11_ips
    channel_12_ips = _mscl.WirelessChannel_channel_12_ips
    channel_13_ips = _mscl.WirelessChannel_channel_13_ips
    channel_14_ips = _mscl.WirelessChannel_channel_14_ips
    channel_15_ips = _mscl.WirelessChannel_channel_15_ips
    channel_16_ips = _mscl.WirelessChannel_channel_16_ips
    channel_1_crestFactor = _mscl.WirelessChannel_channel_1_crestFactor
    channel_2_crestFactor = _mscl.WirelessChannel_channel_2_crestFactor
    channel_3_crestFactor = _mscl.WirelessChannel_channel_3_crestFactor
    channel_4_crestFactor = _mscl.WirelessChannel_channel_4_crestFactor
    channel_5_crestFactor = _mscl.WirelessChannel_channel_5_crestFactor
    channel_6_crestFactor = _mscl.WirelessChannel_channel_6_crestFactor
    channel_7_crestFactor = _mscl.WirelessChannel_channel_7_crestFactor
    channel_8_crestFactor = _mscl.WirelessChannel_channel_8_crestFactor
    channel_9_crestFactor = _mscl.WirelessChannel_channel_9_crestFactor
    channel_10_crestFactor = _mscl.WirelessChannel_channel_10_crestFactor
    channel_11_crestFactor = _mscl.WirelessChannel_channel_11_crestFactor
    channel_12_crestFactor = _mscl.WirelessChannel_channel_12_crestFactor
    channel_13_crestFactor = _mscl.WirelessChannel_channel_13_crestFactor
    channel_14_crestFactor = _mscl.WirelessChannel_channel_14_crestFactor
    channel_15_crestFactor = _mscl.WirelessChannel_channel_15_crestFactor
    channel_16_crestFactor = _mscl.WirelessChannel_channel_16_crestFactor
    channel_diag_syncAttempts = _mscl.WirelessChannel_channel_diag_syncAttempts
    channel_diag_syncFailures = _mscl.WirelessChannel_channel_diag_syncFailures
    channel_diag_secsSinceLastSync = _mscl.WirelessChannel_channel_diag_secsSinceLastSync
    channel_beaconConflict = _mscl.WirelessChannel_channel_beaconConflict
    channel_1_mean = _mscl.WirelessChannel_channel_1_mean
    channel_2_mean = _mscl.WirelessChannel_channel_2_mean
    channel_3_mean = _mscl.WirelessChannel_channel_3_mean
    channel_4_mean = _mscl.WirelessChannel_channel_4_mean
    channel_5_mean = _mscl.WirelessChannel_channel_5_mean
    channel_6_mean = _mscl.WirelessChannel_channel_6_mean
    channel_7_mean = _mscl.WirelessChannel_channel_7_mean
    channel_8_mean = _mscl.WirelessChannel_channel_8_mean
    channel_9_mean = _mscl.WirelessChannel_channel_9_mean
    channel_10_mean = _mscl.WirelessChannel_channel_10_mean
    channel_11_mean = _mscl.WirelessChannel_channel_11_mean
    channel_12_mean = _mscl.WirelessChannel_channel_12_mean
    channel_13_mean = _mscl.WirelessChannel_channel_13_mean
    channel_14_mean = _mscl.WirelessChannel_channel_14_mean
    channel_15_mean = _mscl.WirelessChannel_channel_15_mean
    channel_16_mean = _mscl.WirelessChannel_channel_16_mean
    channel_1_mmps = _mscl.WirelessChannel_channel_1_mmps
    channel_2_mmps = _mscl.WirelessChannel_channel_2_mmps
    channel_3_mmps = _mscl.WirelessChannel_channel_3_mmps
    channel_4_mmps = _mscl.WirelessChannel_channel_4_mmps
    channel_5_mmps = _mscl.WirelessChannel_channel_5_mmps
    channel_6_mmps = _mscl.WirelessChannel_channel_6_mmps
    channel_7_mmps = _mscl.WirelessChannel_channel_7_mmps
    channel_8_mmps = _mscl.WirelessChannel_channel_8_mmps
    channel_9_mmps = _mscl.WirelessChannel_channel_9_mmps
    channel_10_mmps = _mscl.WirelessChannel_channel_10_mmps
    channel_11_mmps = _mscl.WirelessChannel_channel_11_mmps
    channel_12_mmps = _mscl.WirelessChannel_channel_12_mmps
    channel_13_mmps = _mscl.WirelessChannel_channel_13_mmps
    channel_14_mmps = _mscl.WirelessChannel_channel_14_mmps
    channel_15_mmps = _mscl.WirelessChannel_channel_15_mmps
    channel_16_mmps = _mscl.WirelessChannel_channel_16_mmps

    def __init__(self, *args):
        this = _mscl.new_WirelessChannel(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def channelNumber(self):
        return _mscl.WirelessChannel_channelNumber(self)

    def id(self):
        return _mscl.WirelessChannel_id(self)

    def type(self):
        return _mscl.WirelessChannel_type(self)

    def description(self):
        return _mscl.WirelessChannel_description(self)

    def adcResolution(self):
        return _mscl.WirelessChannel_adcResolution(self)

    def adcMaxValue(self):
        return _mscl.WirelessChannel_adcMaxValue(self)

    def name(self):
        return _mscl.WirelessChannel_name(self)
    __swig_destroy__ = _mscl.delete_WirelessChannel
    __del__ = lambda self: None
WirelessChannel_swigregister = _mscl.WirelessChannel_swigregister
WirelessChannel_swigregister(WirelessChannel)

class WirelessDataPoint(DataPoint):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_WirelessDataPoint()
        try:
            self.this.append(this)
        except:
            self.this = this

    def channelId(self):
        return _mscl.WirelessDataPoint_channelId(self)

    def channelNumber(self):
        return _mscl.WirelessDataPoint_channelNumber(self)

    def channelName(self):
        return _mscl.WirelessDataPoint_channelName(self)
    __swig_destroy__ = _mscl.delete_WirelessDataPoint
    __del__ = lambda self: None
WirelessDataPoint_swigregister = _mscl.WirelessDataPoint_swigregister
WirelessDataPoint_swigregister(WirelessDataPoint)

class DataSweep(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    samplingType_NonSync = _mscl.DataSweep_samplingType_NonSync
    samplingType_NonSync_Buffered = _mscl.DataSweep_samplingType_NonSync_Buffered
    samplingType_SyncSampling = _mscl.DataSweep_samplingType_SyncSampling
    samplingType_SyncSampling_Burst = _mscl.DataSweep_samplingType_SyncSampling_Burst
    samplingType_AsyncDigital = _mscl.DataSweep_samplingType_AsyncDigital
    samplingType_AsyncDigitalAnalog = _mscl.DataSweep_samplingType_AsyncDigitalAnalog
    samplingType_SHM = _mscl.DataSweep_samplingType_SHM
    samplingType_BeaconEcho = _mscl.DataSweep_samplingType_BeaconEcho
    samplingType_RfSweep = _mscl.DataSweep_samplingType_RfSweep
    samplingType_Diagnostic = _mscl.DataSweep_samplingType_Diagnostic

    def __init__(self):
        this = _mscl.new_DataSweep()
        try:
            self.this.append(this)
        except:
            self.this = this

    def timestamp(self):
        return _mscl.DataSweep_timestamp(self)

    def tick(self):
        return _mscl.DataSweep_tick(self)

    def sampleRate(self):
        return _mscl.DataSweep_sampleRate(self)

    def nodeAddress(self):
        return _mscl.DataSweep_nodeAddress(self)

    def data(self):
        return _mscl.DataSweep_data(self)

    def samplingType(self):
        return _mscl.DataSweep_samplingType(self)

    def nodeRssi(self):
        return _mscl.DataSweep_nodeRssi(self)

    def baseRssi(self):
        return _mscl.DataSweep_baseRssi(self)

    def frequency(self):
        return _mscl.DataSweep_frequency(self)

    def calApplied(self):
        return _mscl.DataSweep_calApplied(self)
    __swig_destroy__ = _mscl.delete_DataSweep
    __del__ = lambda self: None
DataSweep_swigregister = _mscl.DataSweep_swigregister
DataSweep_swigregister(DataSweep)

class BaseStationAnalogPair(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_BaseStationAnalogPair()
        try:
            self.this.append(this)
        except:
            self.this = this
    Float = staticmethod(_mscl.BaseStationAnalogPair_Float)
    NonFloat = staticmethod(_mscl.BaseStationAnalogPair_NonFloat)

    def nodeAddress(self, *args):
        return _mscl.BaseStationAnalogPair_nodeAddress(self, *args)

    def nodeChannel(self, *args):
        return _mscl.BaseStationAnalogPair_nodeChannel(self, *args)

    def expectFloatData(self, *args):
        return _mscl.BaseStationAnalogPair_expectFloatData(self, *args)

    def outputVal_0V(self, *args):
        return _mscl.BaseStationAnalogPair_outputVal_0V(self, *args)

    def outputVal_3V(self, *args):
        return _mscl.BaseStationAnalogPair_outputVal_3V(self, *args)
    __swig_destroy__ = _mscl.delete_BaseStationAnalogPair
    __del__ = lambda self: None
BaseStationAnalogPair_swigregister = _mscl.BaseStationAnalogPair_swigregister
BaseStationAnalogPair_swigregister(BaseStationAnalogPair)
BaseStationAnalogPair.CHANNEL_NOT_FLOAT = _mscl.cvar.BaseStationAnalogPair_CHANNEL_NOT_FLOAT

def BaseStationAnalogPair_Float(nodeAddress, nodeChannel, output_0V, output_3V):
    return _mscl.BaseStationAnalogPair_Float(nodeAddress, nodeChannel, output_0V, output_3V)
BaseStationAnalogPair_Float = _mscl.BaseStationAnalogPair_Float

def BaseStationAnalogPair_NonFloat(nodeAddress, nodeChannel):
    return _mscl.BaseStationAnalogPair_NonFloat(nodeAddress, nodeChannel)
BaseStationAnalogPair_NonFloat = _mscl.BaseStationAnalogPair_NonFloat

class BaseStationButton(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    btn_nodeSleep = _mscl.BaseStationButton_btn_nodeSleep
    btn_nodeStop = _mscl.BaseStationButton_btn_nodeStop
    btn_enableBeacon = _mscl.BaseStationButton_btn_enableBeacon
    btn_disableBeacon = _mscl.BaseStationButton_btn_disableBeacon
    btn_nodeNonSyncSampling = _mscl.BaseStationButton_btn_nodeNonSyncSampling
    btn_nodeSyncSampling = _mscl.BaseStationButton_btn_nodeSyncSampling
    btn_nodeArmedDatalogging = _mscl.BaseStationButton_btn_nodeArmedDatalogging
    btn_cyclePower = _mscl.BaseStationButton_btn_cyclePower
    btn_disabled = _mscl.BaseStationButton_btn_disabled

    def __init__(self, *args):
        this = _mscl.new_BaseStationButton(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def command(self, *args):
        return _mscl.BaseStationButton_command(self, *args)

    def nodeAddress(self, *args):
        return _mscl.BaseStationButton_nodeAddress(self, *args)
    __swig_destroy__ = _mscl.delete_BaseStationButton
    __del__ = lambda self: None
BaseStationButton_swigregister = _mscl.BaseStationButton_swigregister
BaseStationButton_swigregister(BaseStationButton)

class BaseStationConfig(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_BaseStationConfig()
        try:
            self.this.append(this)
        except:
            self.this = this

    def transmitPower(self, *args):
        return _mscl.BaseStationConfig_transmitPower(self, *args)

    def communicationProtocol(self, *args):
        return _mscl.BaseStationConfig_communicationProtocol(self, *args)

    def buttonLongPress(self, *args):
        return _mscl.BaseStationConfig_buttonLongPress(self, *args)

    def buttonShortPress(self, *args):
        return _mscl.BaseStationConfig_buttonShortPress(self, *args)

    def analogPairingEnable(self, *args):
        return _mscl.BaseStationConfig_analogPairingEnable(self, *args)

    def analogTimeoutTime(self, *args):
        return _mscl.BaseStationConfig_analogTimeoutTime(self, *args)

    def analogTimeoutVoltage(self, *args):
        return _mscl.BaseStationConfig_analogTimeoutVoltage(self, *args)

    def analogExceedanceEnable(self, *args):
        return _mscl.BaseStationConfig_analogExceedanceEnable(self, *args)

    def analogPairing(self, *args):
        return _mscl.BaseStationConfig_analogPairing(self, *args)
    __swig_destroy__ = _mscl.delete_BaseStationConfig
    __del__ = lambda self: None
BaseStationConfig_swigregister = _mscl.BaseStationConfig_swigregister
BaseStationConfig_swigregister(BaseStationConfig)

class BeaconStatus(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_BeaconStatus(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def enabled(self):
        return _mscl.BeaconStatus_enabled(self)

    def timestamp(self):
        return _mscl.BeaconStatus_timestamp(self)
    __swig_destroy__ = _mscl.delete_BeaconStatus
    __del__ = lambda self: None
BeaconStatus_swigregister = _mscl.BeaconStatus_swigregister
BeaconStatus_swigregister(BeaconStatus)

class BaseStationInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, fw, model, region, asppVer_lxrs, asppVer_lxrsPlus):
        this = _mscl.new_BaseStationInfo(fw, model, region, asppVer_lxrs, asppVer_lxrsPlus)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_BaseStationInfo
    __del__ = lambda self: None
BaseStationInfo_swigregister = _mscl.BaseStationInfo_swigregister
BaseStationInfo_swigregister(BaseStationInfo)

class BaseStation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BASE_COMMANDS_DEFAULT_TIMEOUT = _mscl.BaseStation_BASE_COMMANDS_DEFAULT_TIMEOUT
    ETHERNET_BASE_COMMANDS_DEFAULT_TIMEOUT = _mscl.BaseStation_ETHERNET_BASE_COMMANDS_DEFAULT_TIMEOUT
    BROADCAST_NODE_ADDRESS = _mscl.BaseStation_BROADCAST_NODE_ADDRESS
    BROADCAST_NODE_ADDRESS_ASPP3 = _mscl.BaseStation_BROADCAST_NODE_ADDRESS_ASPP3

    def __init__(self, *args):
        this = _mscl.new_BaseStation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_BaseStation
    __del__ = lambda self: None
    Mock = staticmethod(_mscl.BaseStation_Mock)
    deviceName = staticmethod(_mscl.BaseStation_deviceName)

    def connection(self):
        return _mscl.BaseStation_connection(self)

    def features(self):
        return _mscl.BaseStation_features(self)

    def lastCommunicationTime(self):
        return _mscl.BaseStation_lastCommunicationTime(self)

    def readWriteRetries(self, *args):
        return _mscl.BaseStation_readWriteRetries(self, *args)

    def useEepromCache(self, useCache):
        return _mscl.BaseStation_useEepromCache(self, useCache)

    def clearEepromCache(self):
        return _mscl.BaseStation_clearEepromCache(self)

    def frequency(self):
        return _mscl.BaseStation_frequency(self)

    def communicationProtocol(self):
        return _mscl.BaseStation_communicationProtocol(self)

    def firmwareVersion(self):
        return _mscl.BaseStation_firmwareVersion(self)

    def model(self):
        return _mscl.BaseStation_model(self)

    def serial(self):
        return _mscl.BaseStation_serial(self)

    def name(self):
        return _mscl.BaseStation_name(self)

    def microcontroller(self):
        return _mscl.BaseStation_microcontroller(self)

    def regionCode(self):
        return _mscl.BaseStation_regionCode(self)

    def getData(self, timeout=0, maxSweeps=0):
        return _mscl.BaseStation_getData(self, timeout, maxSweeps)

    def totalData(self):
        return _mscl.BaseStation_totalData(self)

    def getNodeDiscoveries(self):
        return _mscl.BaseStation_getNodeDiscoveries(self)

    def timeout(self, *args):
        return _mscl.BaseStation_timeout(self, *args)

    def ping(self):
        return _mscl.BaseStation_ping(self)

    def readEeprom(self, eepromAddress):
        return _mscl.BaseStation_readEeprom(self, eepromAddress)

    def writeEeprom(self, eepromAddress, value):
        return _mscl.BaseStation_writeEeprom(self, eepromAddress, value)

    def enableBeacon(self, *args):
        return _mscl.BaseStation_enableBeacon(self, *args)

    def disableBeacon(self):
        return _mscl.BaseStation_disableBeacon(self)

    def beaconStatus(self):
        return _mscl.BaseStation_beaconStatus(self)

    def startRfSweepMode(self, *args):
        return _mscl.BaseStation_startRfSweepMode(self, *args)

    def cyclePower(self, checkComm=True):
        return _mscl.BaseStation_cyclePower(self, checkComm)

    def resetRadio(self):
        return _mscl.BaseStation_resetRadio(self)

    def changeFrequency(self, frequency):
        return _mscl.BaseStation_changeFrequency(self, frequency)

    def broadcastSetToIdle(self):
        return _mscl.BaseStation_broadcastSetToIdle(self)

    def verifyConfig(self, config, outIssues):
        return _mscl.BaseStation_verifyConfig(self, config, outIssues)

    def applyConfig(self, config):
        return _mscl.BaseStation_applyConfig(self, config)

    def getTransmitPower(self):
        return _mscl.BaseStation_getTransmitPower(self)

    def getButtonLongPress(self, buttonNumber):
        return _mscl.BaseStation_getButtonLongPress(self, buttonNumber)

    def getButtonShortPress(self, buttonNumber):
        return _mscl.BaseStation_getButtonShortPress(self, buttonNumber)

    def getAnalogPairingEnabled(self):
        return _mscl.BaseStation_getAnalogPairingEnabled(self)

    def getAnalogTimeoutTime(self):
        return _mscl.BaseStation_getAnalogTimeoutTime(self)

    def getAnalogTimeoutVoltage(self):
        return _mscl.BaseStation_getAnalogTimeoutVoltage(self)

    def getAnalogExceedanceEnabled(self):
        return _mscl.BaseStation_getAnalogExceedanceEnabled(self)

    def getAnalogPair(self, portNumber):
        return _mscl.BaseStation_getAnalogPair(self, portNumber)
BaseStation_swigregister = _mscl.BaseStation_swigregister
BaseStation_swigregister(BaseStation)

def BaseStation_Mock(*args):
    return _mscl.BaseStation_Mock(*args)
BaseStation_Mock = _mscl.BaseStation_Mock

def BaseStation_deviceName(serial):
    return _mscl.BaseStation_deviceName(serial)
BaseStation_deviceName = _mscl.BaseStation_deviceName

class LoggedDataSweep(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_LoggedDataSweep(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def timestamp(self):
        return _mscl.LoggedDataSweep_timestamp(self)

    def tick(self):
        return _mscl.LoggedDataSweep_tick(self)

    def data(self):
        return _mscl.LoggedDataSweep_data(self)

    def calApplied(self):
        return _mscl.LoggedDataSweep_calApplied(self)
    __swig_destroy__ = _mscl.delete_LoggedDataSweep
    __del__ = lambda self: None
LoggedDataSweep_swigregister = _mscl.LoggedDataSweep_swigregister
LoggedDataSweep_swigregister(LoggedDataSweep)

class RadioFeatures(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_RadioFeatures(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def extendedRange(self):
        return _mscl.RadioFeatures_extendedRange(self)
    __swig_destroy__ = _mscl.delete_RadioFeatures
    __del__ = lambda self: None
RadioFeatures_swigregister = _mscl.RadioFeatures_swigregister
RadioFeatures_swigregister(RadioFeatures)

class WirelessNodeConfig(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_WirelessNodeConfig()
        try:
            self.this.append(this)
        except:
            self.this = this
    SENSOR_DELAY_ALWAYS_ON = _mscl.WirelessNodeConfig_SENSOR_DELAY_ALWAYS_ON

    def defaultMode(self, *args):
        return _mscl.WirelessNodeConfig_defaultMode(self, *args)

    def inactivityTimeout(self, *args):
        return _mscl.WirelessNodeConfig_inactivityTimeout(self, *args)

    def checkRadioInterval(self, *args):
        return _mscl.WirelessNodeConfig_checkRadioInterval(self, *args)

    def transmitPower(self, *args):
        return _mscl.WirelessNodeConfig_transmitPower(self, *args)

    def samplingMode(self, *args):
        return _mscl.WirelessNodeConfig_samplingMode(self, *args)

    def sampleRate(self, *args):
        return _mscl.WirelessNodeConfig_sampleRate(self, *args)

    def activeChannels(self, *args):
        return _mscl.WirelessNodeConfig_activeChannels(self, *args)

    def numSweeps(self, *args):
        return _mscl.WirelessNodeConfig_numSweeps(self, *args)

    def unlimitedDuration(self, *args):
        return _mscl.WirelessNodeConfig_unlimitedDuration(self, *args)

    def dataFormat(self, *args):
        return _mscl.WirelessNodeConfig_dataFormat(self, *args)

    def dataCollectionMethod(self, *args):
        return _mscl.WirelessNodeConfig_dataCollectionMethod(self, *args)

    def timeBetweenBursts(self, *args):
        return _mscl.WirelessNodeConfig_timeBetweenBursts(self, *args)

    def lostBeaconTimeout(self, *args):
        return _mscl.WirelessNodeConfig_lostBeaconTimeout(self, *args)

    def pullUpResistor(self, *args):
        return _mscl.WirelessNodeConfig_pullUpResistor(self, *args)

    def inputRange(self, *args):
        return _mscl.WirelessNodeConfig_inputRange(self, *args)

    def hardwareOffset(self, *args):
        return _mscl.WirelessNodeConfig_hardwareOffset(self, *args)

    def antiAliasingFilter(self, *args):
        return _mscl.WirelessNodeConfig_antiAliasingFilter(self, *args)

    def lowPassFilter(self, *args):
        return _mscl.WirelessNodeConfig_lowPassFilter(self, *args)

    def highPassFilter(self, *args):
        return _mscl.WirelessNodeConfig_highPassFilter(self, *args)

    def gaugeFactor(self, *args):
        return _mscl.WirelessNodeConfig_gaugeFactor(self, *args)

    def gaugeResistance(self, *args):
        return _mscl.WirelessNodeConfig_gaugeResistance(self, *args)

    def excitationVoltage(self, *args):
        return _mscl.WirelessNodeConfig_excitationVoltage(self, *args)

    def numActiveGauges(self, *args):
        return _mscl.WirelessNodeConfig_numActiveGauges(self, *args)

    def linearEquation(self, *args):
        return _mscl.WirelessNodeConfig_linearEquation(self, *args)

    def unit(self, *args):
        return _mscl.WirelessNodeConfig_unit(self, *args)

    def equationType(self, *args):
        return _mscl.WirelessNodeConfig_equationType(self, *args)

    def filterSettlingTime(self, *args):
        return _mscl.WirelessNodeConfig_filterSettlingTime(self, *args)

    def thermocoupleType(self, *args):
        return _mscl.WirelessNodeConfig_thermocoupleType(self, *args)

    def tempSensorOptions(self, *args):
        return _mscl.WirelessNodeConfig_tempSensorOptions(self, *args)

    def debounceFilter(self, *args):
        return _mscl.WirelessNodeConfig_debounceFilter(self, *args)

    def fatigueOptions(self, *args):
        return _mscl.WirelessNodeConfig_fatigueOptions(self, *args)

    def histogramOptions(self, *args):
        return _mscl.WirelessNodeConfig_histogramOptions(self, *args)

    def activitySense(self, *args):
        return _mscl.WirelessNodeConfig_activitySense(self, *args)

    def eventTriggerOptions(self, *args):
        return _mscl.WirelessNodeConfig_eventTriggerOptions(self, *args)

    def diagnosticInterval(self, *args):
        return _mscl.WirelessNodeConfig_diagnosticInterval(self, *args)

    def storageLimitMode(self, *args):
        return _mscl.WirelessNodeConfig_storageLimitMode(self, *args)

    def sensorDelay(self, *args):
        return _mscl.WirelessNodeConfig_sensorDelay(self, *args)

    def dataMode(self, *args):
        return _mscl.WirelessNodeConfig_dataMode(self, *args)

    def derivedDataRate(self, *args):
        return _mscl.WirelessNodeConfig_derivedDataRate(self, *args)

    def derivedChannelMask(self, *args):
        return _mscl.WirelessNodeConfig_derivedChannelMask(self, *args)

    def derivedVelocityUnit(self, *args):
        return _mscl.WirelessNodeConfig_derivedVelocityUnit(self, *args)

    def communicationProtocol(self, *args):
        return _mscl.WirelessNodeConfig_communicationProtocol(self, *args)

    def sensorOutputMode(self, *args):
        return _mscl.WirelessNodeConfig_sensorOutputMode(self, *args)
    flashBandwidth = staticmethod(_mscl.WirelessNodeConfig_flashBandwidth)
    flashBandwidth_burst = staticmethod(_mscl.WirelessNodeConfig_flashBandwidth_burst)
    __swig_destroy__ = _mscl.delete_WirelessNodeConfig
    __del__ = lambda self: None
WirelessNodeConfig_swigregister = _mscl.WirelessNodeConfig_swigregister
WirelessNodeConfig_swigregister(WirelessNodeConfig)

def WirelessNodeConfig_flashBandwidth(rawSampleRate, dataFormat, numRawChannels, derivedBytesPerSweep, derivedRate):
    return _mscl.WirelessNodeConfig_flashBandwidth(rawSampleRate, dataFormat, numRawChannels, derivedBytesPerSweep, derivedRate)
WirelessNodeConfig_flashBandwidth = _mscl.WirelessNodeConfig_flashBandwidth

def WirelessNodeConfig_flashBandwidth_burst(rawSampleRate, dataFormat, numRawChannels, derivedBytesPerSweep, numSweeps, timeBetweenBursts):
    return _mscl.WirelessNodeConfig_flashBandwidth_burst(rawSampleRate, dataFormat, numRawChannels, derivedBytesPerSweep, numSweeps, timeBetweenBursts)
WirelessNodeConfig_flashBandwidth_burst = _mscl.WirelessNodeConfig_flashBandwidth_burst

class AutoBalanceResult(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_AutoBalanceResult()
        try:
            self.this.append(this)
        except:
            self.this = this

    def errorCode(self):
        return _mscl.AutoBalanceResult_errorCode(self)

    def percentAchieved(self):
        return _mscl.AutoBalanceResult_percentAchieved(self)

    def hardwareOffset(self):
        return _mscl.AutoBalanceResult_hardwareOffset(self)
    __swig_destroy__ = _mscl.delete_AutoBalanceResult
    __del__ = lambda self: None
AutoBalanceResult_swigregister = _mscl.AutoBalanceResult_swigregister
AutoBalanceResult_swigregister(AutoBalanceResult)

class ShuntCalCmdInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    useInternalShunt = _swig_property(_mscl.ShuntCalCmdInfo_useInternalShunt_get, _mscl.ShuntCalCmdInfo_useInternalShunt_set)
    numActiveGauges = _swig_property(_mscl.ShuntCalCmdInfo_numActiveGauges_get, _mscl.ShuntCalCmdInfo_numActiveGauges_set)
    gaugeResistance = _swig_property(_mscl.ShuntCalCmdInfo_gaugeResistance_get, _mscl.ShuntCalCmdInfo_gaugeResistance_set)
    shuntResistance = _swig_property(_mscl.ShuntCalCmdInfo_shuntResistance_get, _mscl.ShuntCalCmdInfo_shuntResistance_set)
    gaugeFactor = _swig_property(_mscl.ShuntCalCmdInfo_gaugeFactor_get, _mscl.ShuntCalCmdInfo_gaugeFactor_set)
    inputRange = _swig_property(_mscl.ShuntCalCmdInfo_inputRange_get, _mscl.ShuntCalCmdInfo_inputRange_set)
    hardwareOffset = _swig_property(_mscl.ShuntCalCmdInfo_hardwareOffset_get, _mscl.ShuntCalCmdInfo_hardwareOffset_set)
    excitationVoltage = _swig_property(_mscl.ShuntCalCmdInfo_excitationVoltage_get, _mscl.ShuntCalCmdInfo_excitationVoltage_set)

    def __init__(self):
        this = _mscl.new_ShuntCalCmdInfo()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_ShuntCalCmdInfo
    __del__ = lambda self: None
ShuntCalCmdInfo_swigregister = _mscl.ShuntCalCmdInfo_swigregister
ShuntCalCmdInfo_swigregister(ShuntCalCmdInfo)

class AutoCalResult(object):
    thisown = _swig_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__ = _mscl.delete_AutoCalResult
    __del__ = lambda self: None

    def completionFlag(self):
        return _mscl.AutoCalResult_completionFlag(self)
AutoCalResult_swigregister = _mscl.AutoCalResult_swigregister
AutoCalResult_swigregister(AutoCalResult)

class AutoCalResult_shmLink(AutoCalResult):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_AutoCalResult_shmLink()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_AutoCalResult_shmLink
    __del__ = lambda self: None

    def errorFlagCh1(self):
        return _mscl.AutoCalResult_shmLink_errorFlagCh1(self)

    def errorFlagCh2(self):
        return _mscl.AutoCalResult_shmLink_errorFlagCh2(self)

    def errorFlagCh3(self):
        return _mscl.AutoCalResult_shmLink_errorFlagCh3(self)

    def offsetCh1(self):
        return _mscl.AutoCalResult_shmLink_offsetCh1(self)

    def offsetCh2(self):
        return _mscl.AutoCalResult_shmLink_offsetCh2(self)

    def offsetCh3(self):
        return _mscl.AutoCalResult_shmLink_offsetCh3(self)

    def temperature(self):
        return _mscl.AutoCalResult_shmLink_temperature(self)
AutoCalResult_shmLink_swigregister = _mscl.AutoCalResult_shmLink_swigregister
AutoCalResult_shmLink_swigregister(AutoCalResult_shmLink)

class AutoCalResult_shmLink201(AutoCalResult):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_AutoCalResult_shmLink201()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_AutoCalResult_shmLink201
    __del__ = lambda self: None

    def errorFlagCh1(self):
        return _mscl.AutoCalResult_shmLink201_errorFlagCh1(self)

    def errorFlagCh2(self):
        return _mscl.AutoCalResult_shmLink201_errorFlagCh2(self)

    def errorFlagCh3(self):
        return _mscl.AutoCalResult_shmLink201_errorFlagCh3(self)

    def slopeCh1(self):
        return _mscl.AutoCalResult_shmLink201_slopeCh1(self)

    def offsetCh1(self):
        return _mscl.AutoCalResult_shmLink201_offsetCh1(self)

    def slopeCh2(self):
        return _mscl.AutoCalResult_shmLink201_slopeCh2(self)

    def offsetCh2(self):
        return _mscl.AutoCalResult_shmLink201_offsetCh2(self)

    def slopeCh3(self):
        return _mscl.AutoCalResult_shmLink201_slopeCh3(self)

    def offsetCh3(self):
        return _mscl.AutoCalResult_shmLink201_offsetCh3(self)

    def temperature(self):
        return _mscl.AutoCalResult_shmLink201_temperature(self)
AutoCalResult_shmLink201_swigregister = _mscl.AutoCalResult_shmLink201_swigregister
AutoCalResult_shmLink201_swigregister(AutoCalResult_shmLink201)

class AutoShuntCalResult(AutoCalResult):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_AutoShuntCalResult()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_AutoShuntCalResult
    __del__ = lambda self: None

    def errorFlag(self):
        return _mscl.AutoShuntCalResult_errorFlag(self)

    def slope(self):
        return _mscl.AutoShuntCalResult_slope(self)

    def offset(self):
        return _mscl.AutoShuntCalResult_offset(self)

    def baseMedian(self):
        return _mscl.AutoShuntCalResult_baseMedian(self)

    def baseMin(self):
        return _mscl.AutoShuntCalResult_baseMin(self)

    def baseMax(self):
        return _mscl.AutoShuntCalResult_baseMax(self)

    def shuntMedian(self):
        return _mscl.AutoShuntCalResult_shuntMedian(self)

    def shuntMin(self):
        return _mscl.AutoShuntCalResult_shuntMin(self)

    def shuntMax(self):
        return _mscl.AutoShuntCalResult_shuntMax(self)
AutoShuntCalResult_swigregister = _mscl.AutoShuntCalResult_swigregister
AutoShuntCalResult_swigregister(AutoShuntCalResult)

class PingResponse(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_PingResponse()
        try:
            self.this.append(this)
        except:
            self.this = this

    def success(self):
        return _mscl.PingResponse_success(self)

    def nodeRssi(self):
        return _mscl.PingResponse_nodeRssi(self)

    def baseRssi(self):
        return _mscl.PingResponse_baseRssi(self)
    __swig_destroy__ = _mscl.delete_PingResponse
    __del__ = lambda self: None
PingResponse_swigregister = _mscl.PingResponse_swigregister
PingResponse_swigregister(PingResponse)

class SetToIdleStatus(object):
    thisown = _swig_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
    setToIdleResult_success = _mscl.SetToIdleStatus_setToIdleResult_success
    setToIdleResult_canceled = _mscl.SetToIdleStatus_setToIdleResult_canceled
    setToIdleResult_failed = _mscl.SetToIdleStatus_setToIdleResult_failed
    setToIdleResult_notCompleted = _mscl.SetToIdleStatus_setToIdleResult_notCompleted

    def result(self):
        return _mscl.SetToIdleStatus_result(self)

    def complete(self, timeout=10):
        return _mscl.SetToIdleStatus_complete(self, timeout)

    def cancel(self):
        return _mscl.SetToIdleStatus_cancel(self)
    __swig_destroy__ = _mscl.delete_SetToIdleStatus
    __del__ = lambda self: None
SetToIdleStatus_swigregister = _mscl.SetToIdleStatus_swigregister
SetToIdleStatus_swigregister(SetToIdleStatus)

class NodeInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, fw, model, region):
        this = _mscl.new_NodeInfo(fw, model, region)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_NodeInfo
    __del__ = lambda self: None
NodeInfo_swigregister = _mscl.NodeInfo_swigregister
NodeInfo_swigregister(NodeInfo)

class WirelessNode(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, nodeAddress, basestation):
        this = _mscl.new_WirelessNode(nodeAddress, basestation)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_WirelessNode
    __del__ = lambda self: None
    Mock = staticmethod(_mscl.WirelessNode_Mock)
    deviceName = staticmethod(_mscl.WirelessNode_deviceName)

    def features(self):
        return _mscl.WirelessNode_features(self)

    def lastCommunicationTime(self):
        return _mscl.WirelessNode_lastCommunicationTime(self)

    def setBaseStation(self, basestation):
        return _mscl.WirelessNode_setBaseStation(self, basestation)

    def getBaseStation(self):
        return _mscl.WirelessNode_getBaseStation(self)

    def hasBaseStation(self, basestation):
        return _mscl.WirelessNode_hasBaseStation(self, basestation)

    def useGroupRead(self, useGroup):
        return _mscl.WirelessNode_useGroupRead(self, useGroup)

    def readWriteRetries(self, *args):
        return _mscl.WirelessNode_readWriteRetries(self, *args)

    def useEepromCache(self, useCache):
        return _mscl.WirelessNode_useEepromCache(self, useCache)

    def clearEepromCache(self):
        return _mscl.WirelessNode_clearEepromCache(self)

    def updateEepromCacheFromNodeDiscovery(self, nodeDisovery):
        return _mscl.WirelessNode_updateEepromCacheFromNodeDiscovery(self, nodeDisovery)

    def getEepromCache(self):
        return _mscl.WirelessNode_getEepromCache(self)

    def nodeAddress(self):
        return _mscl.WirelessNode_nodeAddress(self)

    def frequency(self):
        return _mscl.WirelessNode_frequency(self)

    def communicationProtocol(self):
        return _mscl.WirelessNode_communicationProtocol(self)

    def firmwareVersion(self):
        return _mscl.WirelessNode_firmwareVersion(self)

    def model(self):
        return _mscl.WirelessNode_model(self)

    def serial(self):
        return _mscl.WirelessNode_serial(self)

    def name(self):
        return _mscl.WirelessNode_name(self)

    def microcontroller(self):
        return _mscl.WirelessNode_microcontroller(self)

    def radioFeatures(self):
        return _mscl.WirelessNode_radioFeatures(self)

    def dataStorageSize(self):
        return _mscl.WirelessNode_dataStorageSize(self)

    def regionCode(self):
        return _mscl.WirelessNode_regionCode(self)

    def ping(self):
        return _mscl.WirelessNode_ping(self)

    def sleep(self):
        return _mscl.WirelessNode_sleep(self)

    def cyclePower(self):
        return _mscl.WirelessNode_cyclePower(self)

    def resetRadio(self):
        return _mscl.WirelessNode_resetRadio(self)

    def changeFrequency(self, frequency):
        return _mscl.WirelessNode_changeFrequency(self, frequency)

    def setToIdle(self):
        return _mscl.WirelessNode_setToIdle(self)

    def erase(self):
        return _mscl.WirelessNode_erase(self)

    def startNonSyncSampling(self):
        return _mscl.WirelessNode_startNonSyncSampling(self)

    def clearHistogram(self):
        return _mscl.WirelessNode_clearHistogram(self)

    def autoBalance(self, mask, targetPercent):
        return _mscl.WirelessNode_autoBalance(self, mask, targetPercent)

    def autoCal_shmLink(self):
        return _mscl.WirelessNode_autoCal_shmLink(self)

    def autoCal_shmLink201(self):
        return _mscl.WirelessNode_autoCal_shmLink201(self)

    def autoShuntCal(self, mask, commandInfo):
        return _mscl.WirelessNode_autoShuntCal(self, mask, commandInfo)

    def readEeprom(self, location):
        return _mscl.WirelessNode_readEeprom(self, location)

    def writeEeprom(self, location, value):
        return _mscl.WirelessNode_writeEeprom(self, location, value)

    def getDiagnosticInfo(self):
        return _mscl.WirelessNode_getDiagnosticInfo(self)

    def testCommunicationProtocol(self, protocol):
        return _mscl.WirelessNode_testCommunicationProtocol(self, protocol)

    def verifyConfig(self, config, outIssues):
        return _mscl.WirelessNode_verifyConfig(self, config, outIssues)

    def applyConfig(self, config):
        return _mscl.WirelessNode_applyConfig(self, config)

    def getNumDatalogSessions(self):
        return _mscl.WirelessNode_getNumDatalogSessions(self)

    def percentFull(self):
        return _mscl.WirelessNode_percentFull(self)

    def getDefaultMode(self):
        return _mscl.WirelessNode_getDefaultMode(self)

    def getInactivityTimeout(self):
        return _mscl.WirelessNode_getInactivityTimeout(self)

    def getCheckRadioInterval(self):
        return _mscl.WirelessNode_getCheckRadioInterval(self)

    def getTransmitPower(self):
        return _mscl.WirelessNode_getTransmitPower(self)

    def getSamplingMode(self):
        return _mscl.WirelessNode_getSamplingMode(self)

    def getActiveChannels(self):
        return _mscl.WirelessNode_getActiveChannels(self)

    def getSampleRate(self):
        return _mscl.WirelessNode_getSampleRate(self)

    def getNumSweeps(self):
        return _mscl.WirelessNode_getNumSweeps(self)

    def getUnlimitedDuration(self):
        return _mscl.WirelessNode_getUnlimitedDuration(self)

    def getDataFormat(self):
        return _mscl.WirelessNode_getDataFormat(self)

    def getDataCollectionMethod(self):
        return _mscl.WirelessNode_getDataCollectionMethod(self)

    def getTimeBetweenBursts(self):
        return _mscl.WirelessNode_getTimeBetweenBursts(self)

    def getLostBeaconTimeout(self):
        return _mscl.WirelessNode_getLostBeaconTimeout(self)

    def getInputRange(self, mask):
        return _mscl.WirelessNode_getInputRange(self, mask)

    def getHardwareOffset(self, mask):
        return _mscl.WirelessNode_getHardwareOffset(self, mask)

    def getAntiAliasingFilter(self, mask):
        return _mscl.WirelessNode_getAntiAliasingFilter(self, mask)

    def getLowPassFilter(self, mask):
        return _mscl.WirelessNode_getLowPassFilter(self, mask)

    def getHighPassFilter(self, mask):
        return _mscl.WirelessNode_getHighPassFilter(self, mask)

    def getDebounceFilter(self, mask):
        return _mscl.WirelessNode_getDebounceFilter(self, mask)

    def getPullUpResistor(self, mask):
        return _mscl.WirelessNode_getPullUpResistor(self, mask)

    def getSensorOutputMode(self):
        return _mscl.WirelessNode_getSensorOutputMode(self)

    def getGaugeFactor(self, mask):
        return _mscl.WirelessNode_getGaugeFactor(self, mask)

    def getExcitationVoltage(self):
        return _mscl.WirelessNode_getExcitationVoltage(self)

    def getAdcVoltageRef(self):
        return _mscl.WirelessNode_getAdcVoltageRef(self)

    def getGainAmplifierVoltageRef(self):
        return _mscl.WirelessNode_getGainAmplifierVoltageRef(self)

    def getGaugeResistance(self):
        return _mscl.WirelessNode_getGaugeResistance(self)

    def getNumActiveGauges(self):
        return _mscl.WirelessNode_getNumActiveGauges(self)

    def getLinearEquation(self, mask):
        return _mscl.WirelessNode_getLinearEquation(self, mask)

    def getUnit(self, mask):
        return _mscl.WirelessNode_getUnit(self, mask)

    def getEquationType(self, mask):
        return _mscl.WirelessNode_getEquationType(self, mask)

    def getFilterSettlingTime(self, mask):
        return _mscl.WirelessNode_getFilterSettlingTime(self, mask)

    def getThermocoupleType(self, mask):
        return _mscl.WirelessNode_getThermocoupleType(self, mask)

    def getTempSensorOptions(self, mask):
        return _mscl.WirelessNode_getTempSensorOptions(self, mask)

    def getFatigueOptions(self):
        return _mscl.WirelessNode_getFatigueOptions(self)

    def getHistogramOptions(self):
        return _mscl.WirelessNode_getHistogramOptions(self)

    def getActivitySense(self):
        return _mscl.WirelessNode_getActivitySense(self)

    def getEventTriggerOptions(self):
        return _mscl.WirelessNode_getEventTriggerOptions(self)

    def getDiagnosticInterval(self):
        return _mscl.WirelessNode_getDiagnosticInterval(self)

    def getStorageLimitMode(self):
        return _mscl.WirelessNode_getStorageLimitMode(self)

    def getSensorDelay(self):
        return _mscl.WirelessNode_getSensorDelay(self)

    def getDataMode(self):
        return _mscl.WirelessNode_getDataMode(self)

    def getDerivedDataRate(self):
        return _mscl.WirelessNode_getDerivedDataRate(self)

    def getDerivedChannelMask(self, category):
        return _mscl.WirelessNode_getDerivedChannelMask(self, category)

    def getDerivedVelocityUnit(self):
        return _mscl.WirelessNode_getDerivedVelocityUnit(self)
WirelessNode_swigregister = _mscl.WirelessNode_swigregister
WirelessNode_swigregister(WirelessNode)

def WirelessNode_Mock(*args):
    return _mscl.WirelessNode_Mock(*args)
WirelessNode_Mock = _mscl.WirelessNode_Mock

def WirelessNode_deviceName(nodeAddress):
    return _mscl.WirelessNode_deviceName(nodeAddress)
WirelessNode_deviceName = _mscl.WirelessNode_deviceName

class DatalogDownloader(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_DatalogDownloader(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_DatalogDownloader
    __del__ = lambda self: None

    def complete(self):
        return _mscl.DatalogDownloader_complete(self)

    def percentComplete(self):
        return _mscl.DatalogDownloader_percentComplete(self)

    def getNextData(self):
        return _mscl.DatalogDownloader_getNextData(self)

    def metaDataUpdated(self):
        return _mscl.DatalogDownloader_metaDataUpdated(self)

    def calCoefficientsUpdated(self):
        return _mscl.DatalogDownloader_calCoefficientsUpdated(self)

    def startOfSession(self):
        return _mscl.DatalogDownloader_startOfSession(self)

    def sessionIndex(self):
        return _mscl.DatalogDownloader_sessionIndex(self)

    def sampleRate(self):
        return _mscl.DatalogDownloader_sampleRate(self)

    def userString(self):
        return _mscl.DatalogDownloader_userString(self)

    def calCoefficients(self):
        return _mscl.DatalogDownloader_calCoefficients(self)
DatalogDownloader_swigregister = _mscl.DatalogDownloader_swigregister
DatalogDownloader_swigregister(DatalogDownloader)

class ArmedDataloggingNetwork(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, networkBaseStation):
        this = _mscl.new_ArmedDataloggingNetwork(networkBaseStation)
        try:
            self.this.append(this)
        except:
            self.this = this

    def addNode(self, *args):
        return _mscl.ArmedDataloggingNetwork_addNode(self, *args)

    def removeNode(self, nodeAddress):
        return _mscl.ArmedDataloggingNetwork_removeNode(self, nodeAddress)

    def startSampling(self):
        return _mscl.ArmedDataloggingNetwork_startSampling(self)
    __swig_destroy__ = _mscl.delete_ArmedDataloggingNetwork
    __del__ = lambda self: None
ArmedDataloggingNetwork_swigregister = _mscl.ArmedDataloggingNetwork_swigregister
ArmedDataloggingNetwork_swigregister(ArmedDataloggingNetwork)

class SyncNetworkInfo(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    status_OK = _mscl.SyncNetworkInfo_status_OK
    status_PoorCommunication = _mscl.SyncNetworkInfo_status_PoorCommunication
    status_DoesNotFit = _mscl.SyncNetworkInfo_status_DoesNotFit
    status_Contention = _mscl.SyncNetworkInfo_status_Contention

    def __init__(self, node):
        this = _mscl.new_SyncNetworkInfo(node)
        try:
            self.this.append(this)
        except:
            self.this = this

    def status(self):
        return _mscl.SyncNetworkInfo_status(self)

    def configurationApplied(self):
        return _mscl.SyncNetworkInfo_configurationApplied(self)

    def percentBandwidth(self):
        return _mscl.SyncNetworkInfo_percentBandwidth(self)

    def tdmaAddress(self):
        return _mscl.SyncNetworkInfo_tdmaAddress(self)

    def maxTdmaAddress(self):
        return _mscl.SyncNetworkInfo_maxTdmaAddress(self)

    def transmissionPerGroup(self):
        return _mscl.SyncNetworkInfo_transmissionPerGroup(self)

    def groupSize(self):
        return _mscl.SyncNetworkInfo_groupSize(self)
    __swig_destroy__ = _mscl.delete_SyncNetworkInfo
    __del__ = lambda self: None
SyncNetworkInfo_swigregister = _mscl.SyncNetworkInfo_swigregister
SyncNetworkInfo_swigregister(SyncNetworkInfo)

class SyncSamplingNetwork(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, networkBaseStation):
        this = _mscl.new_SyncSamplingNetwork(networkBaseStation)
        try:
            self.this.append(this)
        except:
            self.this = this

    def addNode(self, *args):
        return _mscl.SyncSamplingNetwork_addNode(self, *args)

    def removeNode(self, nodeAddress):
        return _mscl.SyncSamplingNetwork_removeNode(self, nodeAddress)

    def percentBandwidth(self):
        return _mscl.SyncSamplingNetwork_percentBandwidth(self)

    def ok(self):
        return _mscl.SyncSamplingNetwork_ok(self)

    def refresh(self):
        return _mscl.SyncSamplingNetwork_refresh(self)

    def lossless(self, *args):
        return _mscl.SyncSamplingNetwork_lossless(self, *args)

    def communicationProtocol(self, *args):
        return _mscl.SyncSamplingNetwork_communicationProtocol(self, *args)

    def applyConfiguration(self):
        return _mscl.SyncSamplingNetwork_applyConfiguration(self)

    def startSampling(self, *args):
        return _mscl.SyncSamplingNetwork_startSampling(self, *args)

    def startSampling_noBeacon(self):
        return _mscl.SyncSamplingNetwork_startSampling_noBeacon(self)

    def getNodeNetworkInfo(self, nodeAddress):
        return _mscl.SyncSamplingNetwork_getNodeNetworkInfo(self, nodeAddress)
    __swig_destroy__ = _mscl.delete_SyncSamplingNetwork
    __del__ = lambda self: None
SyncSamplingNetwork_swigregister = _mscl.SyncSamplingNetwork_swigregister
SyncSamplingNetwork_swigregister(SyncSamplingNetwork)

class NodeFeatures(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mscl.delete_NodeFeatures
    __del__ = lambda self: None

    def normalizeNumSweeps(self, sweeps):
        return _mscl.NodeFeatures_normalizeNumSweeps(self, sweeps)

    def normalizeTimeBetweenBursts(self, time):
        return _mscl.NodeFeatures_normalizeTimeBetweenBursts(self, time)

    def channels(self):
        return _mscl.NodeFeatures_channels(self)

    def channelGroups(self):
        return _mscl.NodeFeatures_channelGroups(self)

    def channelType(self, channelNumber):
        return _mscl.NodeFeatures_channelType(self, channelNumber)

    def supportsChannelSetting(self, setting, mask):
        return _mscl.NodeFeatures_supportsChannelSetting(self, setting, mask)

    def supportsInputRangePerExcitationVoltage(self):
        return _mscl.NodeFeatures_supportsInputRangePerExcitationVoltage(self)

    def supportsHardwareOffset(self):
        return _mscl.NodeFeatures_supportsHardwareOffset(self)

    def supportsAntiAliasingFilter(self):
        return _mscl.NodeFeatures_supportsAntiAliasingFilter(self)

    def supportsLowPassFilter(self):
        return _mscl.NodeFeatures_supportsLowPassFilter(self)

    def supportsHighPassFilter(self):
        return _mscl.NodeFeatures_supportsHighPassFilter(self)

    def supportsGaugeFactor(self):
        return _mscl.NodeFeatures_supportsGaugeFactor(self)

    def supportsGaugeResistance(self):
        return _mscl.NodeFeatures_supportsGaugeResistance(self)

    def supportsNumActiveGauges(self):
        return _mscl.NodeFeatures_supportsNumActiveGauges(self)

    def supportsLostBeaconTimeout(self):
        return _mscl.NodeFeatures_supportsLostBeaconTimeout(self)

    def supportsPullUpResistor(self):
        return _mscl.NodeFeatures_supportsPullUpResistor(self)

    def supportsFilterSettlingTime(self):
        return _mscl.NodeFeatures_supportsFilterSettlingTime(self)

    def supportsThermocoupleType(self):
        return _mscl.NodeFeatures_supportsThermocoupleType(self)

    def supportsTempSensorOptions(self):
        return _mscl.NodeFeatures_supportsTempSensorOptions(self)

    def supportsDebounceFilter(self):
        return _mscl.NodeFeatures_supportsDebounceFilter(self)

    def supportsFatigueConfig(self):
        return _mscl.NodeFeatures_supportsFatigueConfig(self)

    def supportsYoungsModConfig(self):
        return _mscl.NodeFeatures_supportsYoungsModConfig(self)

    def supportsPoissonsRatioConfig(self):
        return _mscl.NodeFeatures_supportsPoissonsRatioConfig(self)

    def supportsFatigueDebugModeConfig(self):
        return _mscl.NodeFeatures_supportsFatigueDebugModeConfig(self)

    def supportsFatigueModeConfig(self):
        return _mscl.NodeFeatures_supportsFatigueModeConfig(self)

    def supportsHistogramConfig(self):
        return _mscl.NodeFeatures_supportsHistogramConfig(self)

    def supportsHistogramRateConfig(self):
        return _mscl.NodeFeatures_supportsHistogramRateConfig(self)

    def supportsHistogramEnableConfig(self):
        return _mscl.NodeFeatures_supportsHistogramEnableConfig(self)

    def supportsActivitySense(self):
        return _mscl.NodeFeatures_supportsActivitySense(self)

    def supportsAutoBalance(self):
        return _mscl.NodeFeatures_supportsAutoBalance(self)

    def supportsLegacyShuntCal(self):
        return _mscl.NodeFeatures_supportsLegacyShuntCal(self)

    def supportsAutoCal_shm(self):
        return _mscl.NodeFeatures_supportsAutoCal_shm(self)

    def supportsAutoCal_shm201(self):
        return _mscl.NodeFeatures_supportsAutoCal_shm201(self)

    def supportsAutoShuntCal(self):
        return _mscl.NodeFeatures_supportsAutoShuntCal(self)

    def supportsLimitedDuration(self):
        return _mscl.NodeFeatures_supportsLimitedDuration(self)

    def supportsEventTrigger(self):
        return _mscl.NodeFeatures_supportsEventTrigger(self)

    def supportsDiagnosticInfo(self):
        return _mscl.NodeFeatures_supportsDiagnosticInfo(self)

    def supportsLoggedData(self):
        return _mscl.NodeFeatures_supportsLoggedData(self)

    def supportsSensorDelayConfig(self):
        return _mscl.NodeFeatures_supportsSensorDelayConfig(self)

    def supportsSensorDelayAlwaysOn(self):
        return _mscl.NodeFeatures_supportsSensorDelayAlwaysOn(self)

    def supportsSensorOutputMode(self):
        return _mscl.NodeFeatures_supportsSensorOutputMode(self)

    def supportsChannel(self, channelNumber):
        return _mscl.NodeFeatures_supportsChannel(self, channelNumber)

    def supportsSamplingMode(self, samplingMode):
        return _mscl.NodeFeatures_supportsSamplingMode(self, samplingMode)

    def supportsSampleRate(self, sampleRate, samplingMode, dataCollectionMethod, dataMode):
        return _mscl.NodeFeatures_supportsSampleRate(self, sampleRate, samplingMode, dataCollectionMethod, dataMode)

    def supportsCommunicationProtocol(self, protocol):
        return _mscl.NodeFeatures_supportsCommunicationProtocol(self, protocol)

    def supportsDataFormat(self, dataFormat):
        return _mscl.NodeFeatures_supportsDataFormat(self, dataFormat)

    def supportsDefaultMode(self, mode):
        return _mscl.NodeFeatures_supportsDefaultMode(self, mode)

    def supportsDataCollectionMethod(self, collectionMethod):
        return _mscl.NodeFeatures_supportsDataCollectionMethod(self, collectionMethod)

    def supportsTransmitPower(self, power, commProtocol):
        return _mscl.NodeFeatures_supportsTransmitPower(self, power, commProtocol)

    def supportsDataMode(self, dataMode):
        return _mscl.NodeFeatures_supportsDataMode(self, dataMode)

    def supportsFatigueMode(self, mode):
        return _mscl.NodeFeatures_supportsFatigueMode(self, mode)

    def supportsInputRange(self, *args):
        return _mscl.NodeFeatures_supportsInputRange(self, *args)

    def supportsCentisecondEventDuration(self):
        return _mscl.NodeFeatures_supportsCentisecondEventDuration(self)

    def supportsGetDiagnosticInfo(self):
        return _mscl.NodeFeatures_supportsGetDiagnosticInfo(self)

    def supportsNonSyncLogWithTimestamps(self):
        return _mscl.NodeFeatures_supportsNonSyncLogWithTimestamps(self)

    def supportsDerivedCategory(self, category):
        return _mscl.NodeFeatures_supportsDerivedCategory(self, category)

    def supportsRawDataMode(self):
        return _mscl.NodeFeatures_supportsRawDataMode(self)

    def supportsDerivedDataMode(self):
        return _mscl.NodeFeatures_supportsDerivedDataMode(self)

    def supportsDerivedVelocityUnitConfig(self):
        return _mscl.NodeFeatures_supportsDerivedVelocityUnitConfig(self)

    def supportsExcitationVoltageConfig(self):
        return _mscl.NodeFeatures_supportsExcitationVoltageConfig(self)

    def maxSampleRate(self, samplingMode, channels, dataCollectionMethod, dataMode):
        return _mscl.NodeFeatures_maxSampleRate(self, samplingMode, channels, dataCollectionMethod, dataMode)

    def maxSampleRateForSettlingTime(self, filterSettlingTime, samplingMode, dataCollectionMethod, dataMode):
        return _mscl.NodeFeatures_maxSampleRateForSettlingTime(self, filterSettlingTime, samplingMode, dataCollectionMethod, dataMode)

    def maxSampleRateForLowPassFilter(self, lowPassFilter, samplingMode, dataCollectionMethod, dataMode):
        return _mscl.NodeFeatures_maxSampleRateForLowPassFilter(self, lowPassFilter, samplingMode, dataCollectionMethod, dataMode)

    def maxFilterSettlingTime(self, rate):
        return _mscl.NodeFeatures_maxFilterSettlingTime(self, rate)

    def minLowPassFilter(self, rate):
        return _mscl.NodeFeatures_minLowPassFilter(self, rate)

    def minInactivityTimeout(self):
        return _mscl.NodeFeatures_minInactivityTimeout(self)

    def minLostBeaconTimeout(self):
        return _mscl.NodeFeatures_minLostBeaconTimeout(self)

    def maxLostBeaconTimeout(self):
        return _mscl.NodeFeatures_maxLostBeaconTimeout(self)

    def minCheckRadioInterval(self):
        return _mscl.NodeFeatures_minCheckRadioInterval(self)

    def maxCheckRadioInterval(self):
        return _mscl.NodeFeatures_maxCheckRadioInterval(self)

    def minSweeps(self):
        return _mscl.NodeFeatures_minSweeps(self)

    def maxSweeps(self, samplingMode, dataMode, dataFormat, channels):
        return _mscl.NodeFeatures_maxSweeps(self, samplingMode, dataMode, dataFormat, channels)

    def maxSweepsPerBurst(self, dataMode, dataFormat, channels):
        return _mscl.NodeFeatures_maxSweepsPerBurst(self, dataMode, dataFormat, channels)

    def minTimeBetweenBursts(self, dataMode, dataFormat, rawChannels, derivedChannelMasks, rawSampleRate, sweepsPerBurst, commProtocol):
        return _mscl.NodeFeatures_minTimeBetweenBursts(self, dataMode, dataFormat, rawChannels, derivedChannelMasks, rawSampleRate, sweepsPerBurst, commProtocol)

    def minSensorDelay(self):
        return _mscl.NodeFeatures_minSensorDelay(self)

    def maxSensorDelay(self):
        return _mscl.NodeFeatures_maxSensorDelay(self)

    def maxEventTriggerTotalDuration(self, dataMode, dataFormat, rawChannels, derivedChannelMasks, rawSampleRate, derivedDataRate):
        return _mscl.NodeFeatures_maxEventTriggerTotalDuration(self, dataMode, dataFormat, rawChannels, derivedChannelMasks, rawSampleRate, derivedDataRate)

    def normalizeEventDuration(self, duration):
        return _mscl.NodeFeatures_normalizeEventDuration(self, duration)

    def normalizeSensorDelay(self, delay):
        return _mscl.NodeFeatures_normalizeSensorDelay(self, delay)

    def numDamageAngles(self):
        return _mscl.NodeFeatures_numDamageAngles(self)

    def numSnCurveSegments(self):
        return _mscl.NodeFeatures_numSnCurveSegments(self)

    def numEventTriggers(self):
        return _mscl.NodeFeatures_numEventTriggers(self)

    def defaultModes(self):
        return _mscl.NodeFeatures_defaultModes(self)

    def dataCollectionMethods(self):
        return _mscl.NodeFeatures_dataCollectionMethods(self)

    def dataFormats(self):
        return _mscl.NodeFeatures_dataFormats(self)

    def samplingModes(self):
        return _mscl.NodeFeatures_samplingModes(self)

    def sampleRates(self, samplingMode, dataCollectionMethod, dataMode):
        return _mscl.NodeFeatures_sampleRates(self, samplingMode, dataCollectionMethod, dataMode)

    def derivedDataRates(self):
        return _mscl.NodeFeatures_derivedDataRates(self)

    def transmitPowers(self, commProtocol):
        return _mscl.NodeFeatures_transmitPowers(self, commProtocol)

    def commProtocols(self):
        return _mscl.NodeFeatures_commProtocols(self)

    def sensorOutputModes(self):
        return _mscl.NodeFeatures_sensorOutputModes(self)

    def histogramTransmitRates(self):
        return _mscl.NodeFeatures_histogramTransmitRates(self)

    def fatigueModes(self):
        return _mscl.NodeFeatures_fatigueModes(self)

    def antiAliasingFilters(self):
        return _mscl.NodeFeatures_antiAliasingFilters(self)

    def lowPassFilters(self):
        return _mscl.NodeFeatures_lowPassFilters(self)

    def highPassFilters(self):
        return _mscl.NodeFeatures_highPassFilters(self)

    def storageLimitModes(self):
        return _mscl.NodeFeatures_storageLimitModes(self)

    def inputRanges(self, *args):
        return _mscl.NodeFeatures_inputRanges(self, *args)

    def dataModes(self):
        return _mscl.NodeFeatures_dataModes(self)

    def derivedCategories(self):
        return _mscl.NodeFeatures_derivedCategories(self)

    def excitationVoltages(self):
        return _mscl.NodeFeatures_excitationVoltages(self)

    def adcVoltageInputType(self):
        return _mscl.NodeFeatures_adcVoltageInputType(self)

    def maxTransmitPower(self, region, commProtocol):
        return _mscl.NodeFeatures_maxTransmitPower(self, region, commProtocol)

    def minTransmitPower(self, region, commProtocol):
        return _mscl.NodeFeatures_minTransmitPower(self, region, commProtocol)
NodeFeatures_swigregister = _mscl.NodeFeatures_swigregister
NodeFeatures_swigregister(NodeFeatures)

class BaseStationFeatures(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mscl.delete_BaseStationFeatures
    __del__ = lambda self: None

    def supportsTransmitPower(self, power, commProtocol):
        return _mscl.BaseStationFeatures_supportsTransmitPower(self, power, commProtocol)

    def supportsCommunicationProtocol(self, protocol):
        return _mscl.BaseStationFeatures_supportsCommunicationProtocol(self, protocol)

    def supportsButtons(self):
        return _mscl.BaseStationFeatures_supportsButtons(self)

    def supportsAnalogPairing(self):
        return _mscl.BaseStationFeatures_supportsAnalogPairing(self)

    def supportsBeaconStatus(self):
        return _mscl.BaseStationFeatures_supportsBeaconStatus(self)

    def supportsRfSweepMode(self):
        return _mscl.BaseStationFeatures_supportsRfSweepMode(self)

    def supportsCustomRfSweepMode(self):
        return _mscl.BaseStationFeatures_supportsCustomRfSweepMode(self)

    def buttonCount(self):
        return _mscl.BaseStationFeatures_buttonCount(self)

    def analogPortCount(self):
        return _mscl.BaseStationFeatures_analogPortCount(self)

    def transmitPowers(self, commProtocol):
        return _mscl.BaseStationFeatures_transmitPowers(self, commProtocol)

    def commProtocols(self):
        return _mscl.BaseStationFeatures_commProtocols(self)

    def maxTransmitPower(self, region, commProtocol):
        return _mscl.BaseStationFeatures_maxTransmitPower(self, region, commProtocol)

    def minTransmitPower(self, region, commProtocol):
        return _mscl.BaseStationFeatures_minTransmitPower(self, region, commProtocol)
BaseStationFeatures_swigregister = _mscl.BaseStationFeatures_swigregister
BaseStationFeatures_swigregister(BaseStationFeatures)

class InertialTypes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    PORTABLE_VEHICLE = _mscl.InertialTypes_PORTABLE_VEHICLE
    AUTOMOTIVE_VEHICLE = _mscl.InertialTypes_AUTOMOTIVE_VEHICLE
    AIRBORNE_VEHICLE = _mscl.InertialTypes_AIRBORNE_VEHICLE
    AIRBORNE_HIGH_G_VEHICLE = _mscl.InertialTypes_AIRBORNE_HIGH_G_VEHICLE
    INTERNAL_GNSS = _mscl.InertialTypes_INTERNAL_GNSS
    EXTERNAL_GNSS = _mscl.InertialTypes_EXTERNAL_GNSS
    FIXTYPE_3D = _mscl.InertialTypes_FIXTYPE_3D
    FIXTYPE_2D = _mscl.InertialTypes_FIXTYPE_2D
    FIXTYPE_TIMEONLY = _mscl.InertialTypes_FIXTYPE_TIMEONLY
    FIXTYPE_NONE = _mscl.InertialTypes_FIXTYPE_NONE
    FIXTYPE_INVALID = _mscl.InertialTypes_FIXTYPE_INVALID
    SENSORSTATE_OFF = _mscl.InertialTypes_SENSORSTATE_OFF
    SENSORSTATE_ON = _mscl.InertialTypes_SENSORSTATE_ON
    SENSORSTATE_UNKNOWN = _mscl.InertialTypes_SENSORSTATE_UNKNOWN
    ANTENNASTATE_INIT = _mscl.InertialTypes_ANTENNASTATE_INIT
    ANTENNASTATE_SHORT = _mscl.InertialTypes_ANTENNASTATE_SHORT
    ANTENNASTATE_OPEN = _mscl.InertialTypes_ANTENNASTATE_OPEN
    ANTENNASTATE_GOOD = _mscl.InertialTypes_ANTENNASTATE_GOOD
    ANTENNASTATE_UNKNOWN = _mscl.InertialTypes_ANTENNASTATE_UNKNOWN
    ANTENNAPOWER_OFF = _mscl.InertialTypes_ANTENNAPOWER_OFF
    ANTENNAPOWER_ON = _mscl.InertialTypes_ANTENNAPOWER_ON
    ANTENNAPOWER_UNKNOWN = _mscl.InertialTypes_ANTENNAPOWER_UNKNOWN
    FILTERSTATE_STARTUP = _mscl.InertialTypes_FILTERSTATE_STARTUP
    FILTERSTATE_INIT = _mscl.InertialTypes_FILTERSTATE_INIT
    FILTERSTATE_RUNNING_SLN_VALID = _mscl.InertialTypes_FILTERSTATE_RUNNING_SLN_VALID
    FILTERSTATE_RUNNING_SLN_ERROR = _mscl.InertialTypes_FILTERSTATE_RUNNING_SLN_ERROR
    FILTERSTATUS_IMU_UNAVAILABLE = _mscl.InertialTypes_FILTERSTATUS_IMU_UNAVAILABLE
    FILTERSTATUS_GPS_UNAVAILABLE = _mscl.InertialTypes_FILTERSTATUS_GPS_UNAVAILABLE
    FILTERSTATUS_MATRIX_SINGULARITY_IN_CALC = _mscl.InertialTypes_FILTERSTATUS_MATRIX_SINGULARITY_IN_CALC
    FILTERSTATUS_POS_COVARIANCE_HIGH_WARN = _mscl.InertialTypes_FILTERSTATUS_POS_COVARIANCE_HIGH_WARN
    FILTERSTATUS_VEL_COVARIANCE_HIGH_WARN = _mscl.InertialTypes_FILTERSTATUS_VEL_COVARIANCE_HIGH_WARN
    FILTERSTATUS_ATT_COVARIANCE_HIGH_WARN = _mscl.InertialTypes_FILTERSTATUS_ATT_COVARIANCE_HIGH_WARN
    FILTERSTATUS_NAN_IN_SOLUTION = _mscl.InertialTypes_FILTERSTATUS_NAN_IN_SOLUTION
    FILTERSTATUS_ATT_NOT_INIT = _mscl.InertialTypes_FILTERSTATUS_ATT_NOT_INIT
    FILTERSTATUS_POS_VEL_NOT_INIT = _mscl.InertialTypes_FILTERSTATUS_POS_VEL_NOT_INIT
    HEADINGSOURCE_NONE = _mscl.InertialTypes_HEADINGSOURCE_NONE
    HEADINGSOURCE_INTERNAL_MAGNETOMETER = _mscl.InertialTypes_HEADINGSOURCE_INTERNAL_MAGNETOMETER
    HEADINGSOURCE_INTERNAL_GPS_VELOCITY_VECTOR = _mscl.InertialTypes_HEADINGSOURCE_INTERNAL_GPS_VELOCITY_VECTOR
    HEADINGSOURCE_EXTERNAL_HEADING_UPDATE_CMD = _mscl.InertialTypes_HEADINGSOURCE_EXTERNAL_HEADING_UPDATE_CMD
    ENABLE_NONE = _mscl.InertialTypes_ENABLE_NONE
    ENABLE_INTERNAL_MAGNETOMETER = _mscl.InertialTypes_ENABLE_INTERNAL_MAGNETOMETER
    ENABLE_INTERNAL_GNSS = _mscl.InertialTypes_ENABLE_INTERNAL_GNSS
    ENABLE_EXTERNAL_MESSAGES = _mscl.InertialTypes_ENABLE_EXTERNAL_MESSAGES
    ENABLE_MAGNETOMETER_AND_GNSS = _mscl.InertialTypes_ENABLE_MAGNETOMETER_AND_GNSS
    ENABLE_GNSS_AND_EXTERNAL = _mscl.InertialTypes_ENABLE_GNSS_AND_EXTERNAL
    ENABLE_MAGNETOMETER_AND_EXTERNAL = _mscl.InertialTypes_ENABLE_MAGNETOMETER_AND_EXTERNAL
    ENABLE_ALL = _mscl.InertialTypes_ENABLE_ALL
    ENABLE_GYRO_BIAS_ESTIMATION = _mscl.InertialTypes_ENABLE_GYRO_BIAS_ESTIMATION
    ENABLE_ACCEL_BIAS_ESTIMATION = _mscl.InertialTypes_ENABLE_ACCEL_BIAS_ESTIMATION
    ENABLE_GYRO_SCALE_FACTOR_ESTIMATION = _mscl.InertialTypes_ENABLE_GYRO_SCALE_FACTOR_ESTIMATION
    ENABLE_ACCEL_SCALE_FACTOR_ESTIMATION = _mscl.InertialTypes_ENABLE_ACCEL_SCALE_FACTOR_ESTIMATION
    ENABLE_GNSS_ANTENNA_OFFSET_ESTIMATION = _mscl.InertialTypes_ENABLE_GNSS_ANTENNA_OFFSET_ESTIMATION
    ENABLE_HARD_IRON_AUTO_CALIBRATION = _mscl.InertialTypes_ENABLE_HARD_IRON_AUTO_CALIBRATION
    ENABLE_SOFT_IRON_AUTO_CALIBRATION = _mscl.InertialTypes_ENABLE_SOFT_IRON_AUTO_CALIBRATION
    NONE = _mscl.InertialTypes_NONE
    WORLD_MAGNETIC_MODEL = _mscl.InertialTypes_WORLD_MAGNETIC_MODEL
    MANUAL = _mscl.InertialTypes_MANUAL
    ADAPTIVE_MEASUREMENT_DISABLE = _mscl.InertialTypes_ADAPTIVE_MEASUREMENT_DISABLE
    ADAPTIVE_MEASUREMENT_ENABLE_FIXED = _mscl.InertialTypes_ADAPTIVE_MEASUREMENT_ENABLE_FIXED
    ADAPTIVE_MEASUREMENT_ENABLE_AUTO = _mscl.InertialTypes_ADAPTIVE_MEASUREMENT_ENABLE_AUTO

    def __init__(self):
        this = _mscl.new_InertialTypes()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_InertialTypes
    __del__ = lambda self: None
InertialTypes_swigregister = _mscl.InertialTypes_swigregister
InertialTypes_swigregister(InertialTypes)

class Matrix_3x3(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Matrix_3x3(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Matrix_3x3
    __del__ = lambda self: None

    def set(self, row, col, value):
        return _mscl.Matrix_3x3_set(self, row, col, value)

    def at(self, row, col):
        return _mscl.Matrix_3x3_at(self, row, col)
Matrix_3x3_swigregister = _mscl.Matrix_3x3_swigregister
Matrix_3x3_swigregister(Matrix_3x3)

class GeometricVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_GeometricVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_GeometricVector
    __del__ = lambda self: None
    x = _swig_property(_mscl.GeometricVector_x_get, _mscl.GeometricVector_x_set)
    y = _swig_property(_mscl.GeometricVector_y_get, _mscl.GeometricVector_y_set)
    z = _swig_property(_mscl.GeometricVector_z_get, _mscl.GeometricVector_z_set)
GeometricVector_swigregister = _mscl.GeometricVector_swigregister
GeometricVector_swigregister(GeometricVector)

class TimeUpdate(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, timeOfWeek, weekNumber, timeAccuracy=0):
        this = _mscl.new_TimeUpdate(timeOfWeek, weekNumber, timeAccuracy)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_TimeUpdate
    __del__ = lambda self: None

    def timeOfWeek(self):
        return _mscl.TimeUpdate_timeOfWeek(self)

    def weekNumber(self):
        return _mscl.TimeUpdate_weekNumber(self)

    def timeAccuracy(self):
        return _mscl.TimeUpdate_timeAccuracy(self)
TimeUpdate_swigregister = _mscl.TimeUpdate_swigregister
TimeUpdate_swigregister(TimeUpdate)

class ZUPTSettingsData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, enable, threshold):
        this = _mscl.new_ZUPTSettingsData(enable, threshold)
        try:
            self.this.append(this)
        except:
            self.this = this
    enabled = _swig_property(_mscl.ZUPTSettingsData_enabled_get, _mscl.ZUPTSettingsData_enabled_set)
    threshold = _swig_property(_mscl.ZUPTSettingsData_threshold_get, _mscl.ZUPTSettingsData_threshold_set)
    __swig_destroy__ = _mscl.delete_ZUPTSettingsData
    __del__ = lambda self: None
ZUPTSettingsData_swigregister = _mscl.ZUPTSettingsData_swigregister
ZUPTSettingsData_swigregister(ZUPTSettingsData)

class SBASSettingsData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    enableSBAS = _swig_property(_mscl.SBASSettingsData_enableSBAS_get, _mscl.SBASSettingsData_enableSBAS_set)
    enableRanging = _swig_property(_mscl.SBASSettingsData_enableRanging_get, _mscl.SBASSettingsData_enableRanging_set)
    enableCorrectionData = _swig_property(_mscl.SBASSettingsData_enableCorrectionData_get, _mscl.SBASSettingsData_enableCorrectionData_set)
    applyIntegrityInfo = _swig_property(_mscl.SBASSettingsData_applyIntegrityInfo_get, _mscl.SBASSettingsData_applyIntegrityInfo_set)
    satellitePRNs = _swig_property(_mscl.SBASSettingsData_satellitePRNs_get, _mscl.SBASSettingsData_satellitePRNs_set)

    def __init__(self):
        this = _mscl.new_SBASSettingsData()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_SBASSettingsData
    __del__ = lambda self: None
SBASSettingsData_swigregister = _mscl.SBASSettingsData_swigregister
SBASSettingsData_swigregister(SBASSettingsData)

class Constellation(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    constellationID = _swig_property(_mscl.Constellation_constellationID_get, _mscl.Constellation_constellationID_set)
    enabled = _swig_property(_mscl.Constellation_enabled_get, _mscl.Constellation_enabled_set)
    reservedChannelCount = _swig_property(_mscl.Constellation_reservedChannelCount_get, _mscl.Constellation_reservedChannelCount_set)
    maxChannels = _swig_property(_mscl.Constellation_maxChannels_get, _mscl.Constellation_maxChannels_set)
    enableL1SAIF = _swig_property(_mscl.Constellation_enableL1SAIF_get, _mscl.Constellation_enableL1SAIF_set)

    def __init__(self):
        this = _mscl.new_Constellation()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Constellation
    __del__ = lambda self: None
Constellation_swigregister = _mscl.Constellation_swigregister
Constellation_swigregister(Constellation)

class ConstellationSettingsData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    maxChannelsAvailable = _swig_property(_mscl.ConstellationSettingsData_maxChannelsAvailable_get, _mscl.ConstellationSettingsData_maxChannelsAvailable_set)
    maxChannelsToUse = _swig_property(_mscl.ConstellationSettingsData_maxChannelsToUse_get, _mscl.ConstellationSettingsData_maxChannelsToUse_set)
    constellations = _swig_property(_mscl.ConstellationSettingsData_constellations_get, _mscl.ConstellationSettingsData_constellations_set)

    def __init__(self):
        this = _mscl.new_ConstellationSettingsData()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_ConstellationSettingsData
    __del__ = lambda self: None
ConstellationSettingsData_swigregister = _mscl.ConstellationSettingsData_swigregister
ConstellationSettingsData_swigregister(ConstellationSettingsData)

class AdvancedLowPassFilterData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_AdvancedLowPassFilterData()
        try:
            self.this.append(this)
        except:
            self.this = this
    SCALED_ACCEL_DATA = _mscl.AdvancedLowPassFilterData_SCALED_ACCEL_DATA
    SCALED_GYRO_DATA = _mscl.AdvancedLowPassFilterData_SCALED_GYRO_DATA
    SCALED_MAG_DATA = _mscl.AdvancedLowPassFilterData_SCALED_MAG_DATA
    SCALED_PRESSURE_DATA = _mscl.AdvancedLowPassFilterData_SCALED_PRESSURE_DATA
    dataDescriptor = _swig_property(_mscl.AdvancedLowPassFilterData_dataDescriptor_get, _mscl.AdvancedLowPassFilterData_dataDescriptor_set)
    SET_TO_HALF_REPORTING_RATE = _mscl.AdvancedLowPassFilterData_SET_TO_HALF_REPORTING_RATE
    USER_SPECIFIED_CUTOFF_FREQ = _mscl.AdvancedLowPassFilterData_USER_SPECIFIED_CUTOFF_FREQ
    manualFilterBandwidthConfig = _swig_property(_mscl.AdvancedLowPassFilterData_manualFilterBandwidthConfig_get, _mscl.AdvancedLowPassFilterData_manualFilterBandwidthConfig_set)
    applyLowPassFilter = _swig_property(_mscl.AdvancedLowPassFilterData_applyLowPassFilter_get, _mscl.AdvancedLowPassFilterData_applyLowPassFilter_set)
    cutoffFrequency = _swig_property(_mscl.AdvancedLowPassFilterData_cutoffFrequency_get, _mscl.AdvancedLowPassFilterData_cutoffFrequency_set)
    __swig_destroy__ = _mscl.delete_AdvancedLowPassFilterData
    __del__ = lambda self: None
AdvancedLowPassFilterData_swigregister = _mscl.AdvancedLowPassFilterData_swigregister
AdvancedLowPassFilterData_swigregister(AdvancedLowPassFilterData)

class ComplementaryFilterData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_ComplementaryFilterData()
        try:
            self.this.append(this)
        except:
            self.this = this
    upCompensationEnabled = _swig_property(_mscl.ComplementaryFilterData_upCompensationEnabled_get, _mscl.ComplementaryFilterData_upCompensationEnabled_set)
    upCompensationTimeInSeconds = _swig_property(_mscl.ComplementaryFilterData_upCompensationTimeInSeconds_get, _mscl.ComplementaryFilterData_upCompensationTimeInSeconds_set)
    northCompensationEnabled = _swig_property(_mscl.ComplementaryFilterData_northCompensationEnabled_get, _mscl.ComplementaryFilterData_northCompensationEnabled_set)
    northCompensationTimeInSeconds = _swig_property(_mscl.ComplementaryFilterData_northCompensationTimeInSeconds_get, _mscl.ComplementaryFilterData_northCompensationTimeInSeconds_set)
    __swig_destroy__ = _mscl.delete_ComplementaryFilterData
    __del__ = lambda self: None
ComplementaryFilterData_swigregister = _mscl.ComplementaryFilterData_swigregister
ComplementaryFilterData_swigregister(ComplementaryFilterData)

class DeviceStatusData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_DeviceStatusData()
        try:
            self.this.append(this)
        except:
            self.this = this
    systemState = _swig_property(_mscl.DeviceStatusData_systemState_get, _mscl.DeviceStatusData_systemState_set)
    systemTimerInMS = _swig_property(_mscl.DeviceStatusData_systemTimerInMS_get, _mscl.DeviceStatusData_systemTimerInMS_set)
    gnssPowerStateOn = _swig_property(_mscl.DeviceStatusData_gnssPowerStateOn_get, _mscl.DeviceStatusData_gnssPowerStateOn_set)
    numberof1PPSPulses = _swig_property(_mscl.DeviceStatusData_numberof1PPSPulses_get, _mscl.DeviceStatusData_numberof1PPSPulses_set)
    last1PPSInMS = _swig_property(_mscl.DeviceStatusData_last1PPSInMS_get, _mscl.DeviceStatusData_last1PPSInMS_set)
    imuStreamIsEnabled = _swig_property(_mscl.DeviceStatusData_imuStreamIsEnabled_get, _mscl.DeviceStatusData_imuStreamIsEnabled_set)
    gnssStreamIsEnabled = _swig_property(_mscl.DeviceStatusData_gnssStreamIsEnabled_get, _mscl.DeviceStatusData_gnssStreamIsEnabled_set)
    estimationFilterStreamIsEnabled = _swig_property(_mscl.DeviceStatusData_estimationFilterStreamIsEnabled_get, _mscl.DeviceStatusData_estimationFilterStreamIsEnabled_set)
    outgoingIMUDroppedPacketCount = _swig_property(_mscl.DeviceStatusData_outgoingIMUDroppedPacketCount_get, _mscl.DeviceStatusData_outgoingIMUDroppedPacketCount_set)
    outgoingGnssDroppedPacketCount = _swig_property(_mscl.DeviceStatusData_outgoingGnssDroppedPacketCount_get, _mscl.DeviceStatusData_outgoingGnssDroppedPacketCount_set)
    outgoingEstimationFilterDroppedPacketCount = _swig_property(_mscl.DeviceStatusData_outgoingEstimationFilterDroppedPacketCount_get, _mscl.DeviceStatusData_outgoingEstimationFilterDroppedPacketCount_set)
    numOfBytesWrittenToComPort = _swig_property(_mscl.DeviceStatusData_numOfBytesWrittenToComPort_get, _mscl.DeviceStatusData_numOfBytesWrittenToComPort_set)
    numOfBytesWrittenFromComPort = _swig_property(_mscl.DeviceStatusData_numOfBytesWrittenFromComPort_get, _mscl.DeviceStatusData_numOfBytesWrittenFromComPort_set)
    numOfOverrunsOnWriteToComPort = _swig_property(_mscl.DeviceStatusData_numOfOverrunsOnWriteToComPort_get, _mscl.DeviceStatusData_numOfOverrunsOnWriteToComPort_set)
    numOfIMUParsingErrors = _swig_property(_mscl.DeviceStatusData_numOfIMUParsingErrors_get, _mscl.DeviceStatusData_numOfIMUParsingErrors_set)
    totalIMUMessagesRead = _swig_property(_mscl.DeviceStatusData_totalIMUMessagesRead_get, _mscl.DeviceStatusData_totalIMUMessagesRead_set)
    lastIMUMessageReadInMS = _swig_property(_mscl.DeviceStatusData_lastIMUMessageReadInMS_get, _mscl.DeviceStatusData_lastIMUMessageReadInMS_set)
    numOfGnssParsingErrors = _swig_property(_mscl.DeviceStatusData_numOfGnssParsingErrors_get, _mscl.DeviceStatusData_numOfGnssParsingErrors_set)
    totalGnssMessagesRead = _swig_property(_mscl.DeviceStatusData_totalGnssMessagesRead_get, _mscl.DeviceStatusData_totalGnssMessagesRead_set)
    lastGnssMessageReadInMS = _swig_property(_mscl.DeviceStatusData_lastGnssMessageReadInMS_get, _mscl.DeviceStatusData_lastGnssMessageReadInMS_set)
    __swig_destroy__ = _mscl.delete_DeviceStatusData
    __del__ = lambda self: None
DeviceStatusData_swigregister = _mscl.DeviceStatusData_swigregister
DeviceStatusData_swigregister(DeviceStatusData)

class ExternalGNSSUpdateData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    gpsTimeOfWeek = _swig_property(_mscl.ExternalGNSSUpdateData_gpsTimeOfWeek_get, _mscl.ExternalGNSSUpdateData_gpsTimeOfWeek_set)
    gpsWeekNumber = _swig_property(_mscl.ExternalGNSSUpdateData_gpsWeekNumber_get, _mscl.ExternalGNSSUpdateData_gpsWeekNumber_set)
    lattitude = _swig_property(_mscl.ExternalGNSSUpdateData_lattitude_get, _mscl.ExternalGNSSUpdateData_lattitude_set)
    longitude = _swig_property(_mscl.ExternalGNSSUpdateData_longitude_get, _mscl.ExternalGNSSUpdateData_longitude_set)
    altitudeAboveWGS84Ellipsoid = _swig_property(_mscl.ExternalGNSSUpdateData_altitudeAboveWGS84Ellipsoid_get, _mscl.ExternalGNSSUpdateData_altitudeAboveWGS84Ellipsoid_set)
    northVelocity = _swig_property(_mscl.ExternalGNSSUpdateData_northVelocity_get, _mscl.ExternalGNSSUpdateData_northVelocity_set)
    eastVelocity = _swig_property(_mscl.ExternalGNSSUpdateData_eastVelocity_get, _mscl.ExternalGNSSUpdateData_eastVelocity_set)
    downVelocity = _swig_property(_mscl.ExternalGNSSUpdateData_downVelocity_get, _mscl.ExternalGNSSUpdateData_downVelocity_set)
    northPositionUncertainty = _swig_property(_mscl.ExternalGNSSUpdateData_northPositionUncertainty_get, _mscl.ExternalGNSSUpdateData_northPositionUncertainty_set)
    eastPositionUncertainty = _swig_property(_mscl.ExternalGNSSUpdateData_eastPositionUncertainty_get, _mscl.ExternalGNSSUpdateData_eastPositionUncertainty_set)
    downPositionUncertainty = _swig_property(_mscl.ExternalGNSSUpdateData_downPositionUncertainty_get, _mscl.ExternalGNSSUpdateData_downPositionUncertainty_set)
    northVelocityUncertainty = _swig_property(_mscl.ExternalGNSSUpdateData_northVelocityUncertainty_get, _mscl.ExternalGNSSUpdateData_northVelocityUncertainty_set)
    eastVelocityUncertainty = _swig_property(_mscl.ExternalGNSSUpdateData_eastVelocityUncertainty_get, _mscl.ExternalGNSSUpdateData_eastVelocityUncertainty_set)
    downVelocityUncertainty = _swig_property(_mscl.ExternalGNSSUpdateData_downVelocityUncertainty_get, _mscl.ExternalGNSSUpdateData_downVelocityUncertainty_set)

    def __init__(self):
        this = _mscl.new_ExternalGNSSUpdateData()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_ExternalGNSSUpdateData
    __del__ = lambda self: None
ExternalGNSSUpdateData_swigregister = _mscl.ExternalGNSSUpdateData_swigregister
ExternalGNSSUpdateData_swigregister(ExternalGNSSUpdateData)

class HeadingUpdateOptions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def AsOptionId(self):
        return _mscl.HeadingUpdateOptions_AsOptionId(self)

    def __init__(self, *args):
        this = _mscl.new_HeadingUpdateOptions(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    useInternalMagnetometer = _swig_property(_mscl.HeadingUpdateOptions_useInternalMagnetometer_get, _mscl.HeadingUpdateOptions_useInternalMagnetometer_set)
    useInternalGNSSVelocityVector = _swig_property(_mscl.HeadingUpdateOptions_useInternalGNSSVelocityVector_get, _mscl.HeadingUpdateOptions_useInternalGNSSVelocityVector_set)
    useExternalHeadingMessages = _swig_property(_mscl.HeadingUpdateOptions_useExternalHeadingMessages_get, _mscl.HeadingUpdateOptions_useExternalHeadingMessages_set)
    __swig_destroy__ = _mscl.delete_HeadingUpdateOptions
    __del__ = lambda self: None
HeadingUpdateOptions_swigregister = _mscl.HeadingUpdateOptions_swigregister
HeadingUpdateOptions_swigregister(HeadingUpdateOptions)

class GeographicSourceOptions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_GeographicSourceOptions(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    source = _swig_property(_mscl.GeographicSourceOptions_source_get, _mscl.GeographicSourceOptions_source_set)
    fixed = _swig_property(_mscl.GeographicSourceOptions_fixed_get, _mscl.GeographicSourceOptions_fixed_set)
    __swig_destroy__ = _mscl.delete_GeographicSourceOptions
    __del__ = lambda self: None
GeographicSourceOptions_swigregister = _mscl.GeographicSourceOptions_swigregister
GeographicSourceOptions_swigregister(GeographicSourceOptions)

class EstimationControlOptions(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def AsUint16(self):
        return _mscl.EstimationControlOptions_AsUint16(self)

    def __init__(self, *args):
        this = _mscl.new_EstimationControlOptions(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    enableGyroBiasEstimation = _swig_property(_mscl.EstimationControlOptions_enableGyroBiasEstimation_get, _mscl.EstimationControlOptions_enableGyroBiasEstimation_set)
    enableAccelBiasEstimation = _swig_property(_mscl.EstimationControlOptions_enableAccelBiasEstimation_get, _mscl.EstimationControlOptions_enableAccelBiasEstimation_set)
    enableGyroScaleFactorEstimation = _swig_property(_mscl.EstimationControlOptions_enableGyroScaleFactorEstimation_get, _mscl.EstimationControlOptions_enableGyroScaleFactorEstimation_set)
    enableAccelScaleFactorEstimation = _swig_property(_mscl.EstimationControlOptions_enableAccelScaleFactorEstimation_get, _mscl.EstimationControlOptions_enableAccelScaleFactorEstimation_set)
    enableGNSSAntennaOffsetEstimation = _swig_property(_mscl.EstimationControlOptions_enableGNSSAntennaOffsetEstimation_get, _mscl.EstimationControlOptions_enableGNSSAntennaOffsetEstimation_set)
    enableHardIronAutoCalibration = _swig_property(_mscl.EstimationControlOptions_enableHardIronAutoCalibration_get, _mscl.EstimationControlOptions_enableHardIronAutoCalibration_set)
    enableSoftIronAutoCalibration = _swig_property(_mscl.EstimationControlOptions_enableSoftIronAutoCalibration_get, _mscl.EstimationControlOptions_enableSoftIronAutoCalibration_set)
    __swig_destroy__ = _mscl.delete_EstimationControlOptions
    __del__ = lambda self: None
EstimationControlOptions_swigregister = _mscl.EstimationControlOptions_swigregister
EstimationControlOptions_swigregister(EstimationControlOptions)

class HeadingData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_HeadingData()
        try:
            self.this.append(this)
        except:
            self.this = this
    TRUE_HEADING = _mscl.HeadingData_TRUE_HEADING
    MAGNETIC_HEADING = _mscl.HeadingData_MAGNETIC_HEADING
    heading = _swig_property(_mscl.HeadingData_heading_get, _mscl.HeadingData_heading_set)
    headingAngle = _swig_property(_mscl.HeadingData_headingAngle_get, _mscl.HeadingData_headingAngle_set)
    headingAngleUncertainty = _swig_property(_mscl.HeadingData_headingAngleUncertainty_get, _mscl.HeadingData_headingAngleUncertainty_set)
    __swig_destroy__ = _mscl.delete_HeadingData
    __del__ = lambda self: None
HeadingData_swigregister = _mscl.HeadingData_swigregister
HeadingData_swigregister(HeadingData)

class AdaptiveMeasurementData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_AdaptiveMeasurementData()
        try:
            self.this.append(this)
        except:
            self.this = this
    mode = _swig_property(_mscl.AdaptiveMeasurementData_mode_get, _mscl.AdaptiveMeasurementData_mode_set)
    lowPassFilterCutoff = _swig_property(_mscl.AdaptiveMeasurementData_lowPassFilterCutoff_get, _mscl.AdaptiveMeasurementData_lowPassFilterCutoff_set)
    lowLimit = _swig_property(_mscl.AdaptiveMeasurementData_lowLimit_get, _mscl.AdaptiveMeasurementData_lowLimit_set)
    highLimit = _swig_property(_mscl.AdaptiveMeasurementData_highLimit_get, _mscl.AdaptiveMeasurementData_highLimit_set)
    lowLimitUncertainty = _swig_property(_mscl.AdaptiveMeasurementData_lowLimitUncertainty_get, _mscl.AdaptiveMeasurementData_lowLimitUncertainty_set)
    highLimitUncertainty = _swig_property(_mscl.AdaptiveMeasurementData_highLimitUncertainty_get, _mscl.AdaptiveMeasurementData_highLimitUncertainty_set)
    minUncertainty = _swig_property(_mscl.AdaptiveMeasurementData_minUncertainty_get, _mscl.AdaptiveMeasurementData_minUncertainty_set)
    __swig_destroy__ = _mscl.delete_AdaptiveMeasurementData
    __del__ = lambda self: None
AdaptiveMeasurementData_swigregister = _mscl.AdaptiveMeasurementData_swigregister
AdaptiveMeasurementData_swigregister(AdaptiveMeasurementData)

class EulerAngles(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_EulerAngles(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def roll(self):
        return _mscl.EulerAngles_roll(self)

    def pitch(self):
        return _mscl.EulerAngles_pitch(self)

    def yaw(self):
        return _mscl.EulerAngles_yaw(self)
    __swig_destroy__ = _mscl.delete_EulerAngles
    __del__ = lambda self: None
EulerAngles_swigregister = _mscl.EulerAngles_swigregister
EulerAngles_swigregister(EulerAngles)

class PositionOffset(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_PositionOffset(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def x(self):
        return _mscl.PositionOffset_x(self)

    def y(self):
        return _mscl.PositionOffset_y(self)

    def z(self):
        return _mscl.PositionOffset_z(self)
    __swig_destroy__ = _mscl.delete_PositionOffset
    __del__ = lambda self: None
PositionOffset_swigregister = _mscl.PositionOffset_swigregister
PositionOffset_swigregister(PositionOffset)

class InertialModels(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    node_3dm = _mscl.InertialModels_node_3dm
    node_fasA = _mscl.InertialModels_node_fasA
    node_3dm_gx2 = _mscl.InertialModels_node_3dm_gx2
    node_3dm_dh3 = _mscl.InertialModels_node_3dm_dh3
    node_3dm_gx3_15 = _mscl.InertialModels_node_3dm_gx3_15
    node_3dm_gx3_25 = _mscl.InertialModels_node_3dm_gx3_25
    node_3dm_gx3_35 = _mscl.InertialModels_node_3dm_gx3_35
    node_3dm_gx3_45 = _mscl.InertialModels_node_3dm_gx3_45
    node_3dm_rq1_45 = _mscl.InertialModels_node_3dm_rq1_45
    node_3dm_gx4_15 = _mscl.InertialModels_node_3dm_gx4_15
    node_3dm_gx4_25 = _mscl.InertialModels_node_3dm_gx4_25
    node_3dm_gx4_45 = _mscl.InertialModels_node_3dm_gx4_45
    node_3dm_gx5_10 = _mscl.InertialModels_node_3dm_gx5_10
    node_3dm_gx5_15 = _mscl.InertialModels_node_3dm_gx5_15
    node_3dm_gx5_25 = _mscl.InertialModels_node_3dm_gx5_25
    node_3dm_gx5_35 = _mscl.InertialModels_node_3dm_gx5_35
    node_3dm_gx5_45 = _mscl.InertialModels_node_3dm_gx5_45
    node_3dm_cv5_10 = _mscl.InertialModels_node_3dm_cv5_10
    node_3dm_cv5_15 = _mscl.InertialModels_node_3dm_cv5_15
    node_3dm_cv5_25 = _mscl.InertialModels_node_3dm_cv5_25
    node_3dm_cv5_45 = _mscl.InertialModels_node_3dm_cv5_45
    node_3dm_gq4_45 = _mscl.InertialModels_node_3dm_gq4_45

    def __init__(self):
        this = _mscl.new_InertialModels()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_InertialModels
    __del__ = lambda self: None
InertialModels_swigregister = _mscl.InertialModels_swigregister
InertialModels_swigregister(InertialModels)

class DisplacementModels(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    node_digitalDemod = _mscl.DisplacementModels_node_digitalDemod

    def __init__(self):
        this = _mscl.new_DisplacementModels()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_DisplacementModels
    __del__ = lambda self: None
DisplacementModels_swigregister = _mscl.DisplacementModels_swigregister
DisplacementModels_swigregister(DisplacementModels)

class MipTypes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CLASS_AHRS_IMU = _mscl.MipTypes_CLASS_AHRS_IMU
    CLASS_GNSS = _mscl.MipTypes_CLASS_GNSS
    CLASS_ESTFILTER = _mscl.MipTypes_CLASS_ESTFILTER
    CLASS_DISPLACEMENT = _mscl.MipTypes_CLASS_DISPLACEMENT
    USE_NEW_SETTINGS = _mscl.MipTypes_USE_NEW_SETTINGS
    READ_BACK_CURRENT_SETTINGS = _mscl.MipTypes_READ_BACK_CURRENT_SETTINGS
    SAVE_CURRENT_SETTINGS = _mscl.MipTypes_SAVE_CURRENT_SETTINGS
    LOAD_STARTUP_SETTINGS = _mscl.MipTypes_LOAD_STARTUP_SETTINGS
    RESET_TO_DEFAULT = _mscl.MipTypes_RESET_TO_DEFAULT
    BASIC_STATUS_STRUCTURE = _mscl.MipTypes_BASIC_STATUS_STRUCTURE
    DIAGNOSTIC_STATUS_STRUCTURE = _mscl.MipTypes_DIAGNOSTIC_STATUS_STRUCTURE
    DISABLED = _mscl.MipTypes_DISABLED
    ENABLED = _mscl.MipTypes_ENABLED
    TIME_FRAME_WEEKS = _mscl.MipTypes_TIME_FRAME_WEEKS
    TIME_FRAME_SECONDS = _mscl.MipTypes_TIME_FRAME_SECONDS
    CMD_PING = _mscl.MipTypes_CMD_PING
    CMD_SET_IDLE = _mscl.MipTypes_CMD_SET_IDLE
    CMD_GET_DEVICE_INFO = _mscl.MipTypes_CMD_GET_DEVICE_INFO
    CMD_GET_DESCRIPTOR_SETS = _mscl.MipTypes_CMD_GET_DESCRIPTOR_SETS
    CMD_BUILT_IN_TEST = _mscl.MipTypes_CMD_BUILT_IN_TEST
    CMD_RESUME = _mscl.MipTypes_CMD_RESUME
    CMD_GET_EXT_DESCRIPTOR_SETS = _mscl.MipTypes_CMD_GET_EXT_DESCRIPTOR_SETS
    CMD_GPS_TIME_UPDATE = _mscl.MipTypes_CMD_GPS_TIME_UPDATE
    CMD_RESET = _mscl.MipTypes_CMD_RESET
    CMD_POLL_SENSOR_DATA = _mscl.MipTypes_CMD_POLL_SENSOR_DATA
    CMD_POLL_GNSS_DATA = _mscl.MipTypes_CMD_POLL_GNSS_DATA
    CMD_POLL_EF_DATA = _mscl.MipTypes_CMD_POLL_EF_DATA
    CMD_GET_SENSOR_RATE_BASE = _mscl.MipTypes_CMD_GET_SENSOR_RATE_BASE
    CMD_GET_GNSS_RATE_BASE = _mscl.MipTypes_CMD_GET_GNSS_RATE_BASE
    CMD_GET_EF_RATE_BASE = _mscl.MipTypes_CMD_GET_EF_RATE_BASE
    CMD_SENSOR_MESSAGE_FORMAT = _mscl.MipTypes_CMD_SENSOR_MESSAGE_FORMAT
    CMD_GNSS_MESSAGE_FORMAT = _mscl.MipTypes_CMD_GNSS_MESSAGE_FORMAT
    CMD_EF_MESSAGE_FORMAT = _mscl.MipTypes_CMD_EF_MESSAGE_FORMAT
    CMD_CONTINUOUS_DATA_STREAM = _mscl.MipTypes_CMD_CONTINUOUS_DATA_STREAM
    CMD_RAW_RTCM_2_3_MESSAGE = _mscl.MipTypes_CMD_RAW_RTCM_2_3_MESSAGE
    CMD_GNSS_CONSTELLATION_SETTINGS = _mscl.MipTypes_CMD_GNSS_CONSTELLATION_SETTINGS
    CMD_GNSS_SBAS_SETTINGS = _mscl.MipTypes_CMD_GNSS_SBAS_SETTINGS
    CMD_GNSS_ASSIST_FIX_CONTROL = _mscl.MipTypes_CMD_GNSS_ASSIST_FIX_CONTROL
    CMD_GNSS_ASSIST_TIME_UPDATE = _mscl.MipTypes_CMD_GNSS_ASSIST_TIME_UPDATE
    CMD_SAVE_STARTUP_SETTINGS = _mscl.MipTypes_CMD_SAVE_STARTUP_SETTINGS
    CMD_GPS_DYNAMICS_MODE = _mscl.MipTypes_CMD_GPS_DYNAMICS_MODE
    CMD_SENSOR_SIG_COND_SETTINGS = _mscl.MipTypes_CMD_SENSOR_SIG_COND_SETTINGS
    CMD_SENSOR_TIMESTAMP = _mscl.MipTypes_CMD_SENSOR_TIMESTAMP
    CMD_ACCEL_BIAS = _mscl.MipTypes_CMD_ACCEL_BIAS
    CMD_GYRO_BIAS = _mscl.MipTypes_CMD_GYRO_BIAS
    CMD_CAP_GYRO_BIAS = _mscl.MipTypes_CMD_CAP_GYRO_BIAS
    CMD_MAG_HARD_IRON_OFFSET = _mscl.MipTypes_CMD_MAG_HARD_IRON_OFFSET
    CMD_MAG_SOFT_IRON_MATRIX = _mscl.MipTypes_CMD_MAG_SOFT_IRON_MATRIX
    CMD_CF_REALIGN_UP = _mscl.MipTypes_CMD_CF_REALIGN_UP
    CMD_CF_REALIGN_NORTH = _mscl.MipTypes_CMD_CF_REALIGN_NORTH
    CMD_CONING_SCULLING = _mscl.MipTypes_CMD_CONING_SCULLING
    CMD_UART_BAUD_RATE = _mscl.MipTypes_CMD_UART_BAUD_RATE
    CMD_LOWPASS_FILTER_SETTINGS = _mscl.MipTypes_CMD_LOWPASS_FILTER_SETTINGS
    CMD_COMPLEMENTARY_FILTER_SETTINGS = _mscl.MipTypes_CMD_COMPLEMENTARY_FILTER_SETTINGS
    CMD_DATA_STREAM_FORMAT = _mscl.MipTypes_CMD_DATA_STREAM_FORMAT
    CMD_POWER_STATES = _mscl.MipTypes_CMD_POWER_STATES
    CMD_GPS_STARTUP_SETTINGS = _mscl.MipTypes_CMD_GPS_STARTUP_SETTINGS
    CMD_DEVICE_STATUS = _mscl.MipTypes_CMD_DEVICE_STATUS
    CMD_EF_RESET_FILTER = _mscl.MipTypes_CMD_EF_RESET_FILTER
    CMD_EF_INIT_ATTITUDE = _mscl.MipTypes_CMD_EF_INIT_ATTITUDE
    CMD_EF_INIT_HEADING = _mscl.MipTypes_CMD_EF_INIT_HEADING
    CMD_EF_INIT_ATTITUDE_FROM_AHRS = _mscl.MipTypes_CMD_EF_INIT_ATTITUDE_FROM_AHRS
    CMD_EF_VEHIC_DYNAMICS_MODE = _mscl.MipTypes_CMD_EF_VEHIC_DYNAMICS_MODE
    CMD_EF_SENS_VEHIC_FRAME_TRANS = _mscl.MipTypes_CMD_EF_SENS_VEHIC_FRAME_TRANS
    CMD_EF_SENS_VEHIC_FRAME_OFFSET = _mscl.MipTypes_CMD_EF_SENS_VEHIC_FRAME_OFFSET
    CMD_EF_ANTENNA_OFFSET = _mscl.MipTypes_CMD_EF_ANTENNA_OFFSET
    CMD_EF_BIAS_EST_CTRL = _mscl.MipTypes_CMD_EF_BIAS_EST_CTRL
    CMD_EF_GNSS_SRC_CTRL = _mscl.MipTypes_CMD_EF_GNSS_SRC_CTRL
    CMD_EF_EXTERN_GNSS_UPDATE = _mscl.MipTypes_CMD_EF_EXTERN_GNSS_UPDATE
    CMD_EF_EXTERN_HEADING_UPDATE = _mscl.MipTypes_CMD_EF_EXTERN_HEADING_UPDATE
    CMD_EF_HEADING_UPDATE_CTRL = _mscl.MipTypes_CMD_EF_HEADING_UPDATE_CTRL
    CMD_EF_AUTO_INIT_CTRL = _mscl.MipTypes_CMD_EF_AUTO_INIT_CTRL
    CMD_EF_ACCEL_WHT_NSE_STD_DEV = _mscl.MipTypes_CMD_EF_ACCEL_WHT_NSE_STD_DEV
    CMD_EF_GYRO_WHT_NSE_STD_DEV = _mscl.MipTypes_CMD_EF_GYRO_WHT_NSE_STD_DEV
    CMD_EF_ACCEL_BIAS_MODEL_PARAMS = _mscl.MipTypes_CMD_EF_ACCEL_BIAS_MODEL_PARAMS
    CMD_EF_GYRO_BIAS_MODEL_PARAMS = _mscl.MipTypes_CMD_EF_GYRO_BIAS_MODEL_PARAMS
    CMD_EF_ZERO_VEL_UPDATE_CTRL = _mscl.MipTypes_CMD_EF_ZERO_VEL_UPDATE_CTRL
    CMD_EF_EXT_HEADING_UPDATE_TS = _mscl.MipTypes_CMD_EF_EXT_HEADING_UPDATE_TS
    CMD_EF_ZERO_ANG_RATE_UPDATE_CTRL = _mscl.MipTypes_CMD_EF_ZERO_ANG_RATE_UPDATE_CTRL
    CMD_EF_TARE_ORIENT = _mscl.MipTypes_CMD_EF_TARE_ORIENT
    CMD_EF_CMDED_ZERO_VEL_UPDATE = _mscl.MipTypes_CMD_EF_CMDED_ZERO_VEL_UPDATE
    CMD_EF_CMDED_ZERO_ANG_RATE_UPDATE = _mscl.MipTypes_CMD_EF_CMDED_ZERO_ANG_RATE_UPDATE
    CMD_EF_MAG_CAPTURE_AUTO_CAL = _mscl.MipTypes_CMD_EF_MAG_CAPTURE_AUTO_CAL
    CMD_EF_GRAVITY_NOISE_STD_DEV = _mscl.MipTypes_CMD_EF_GRAVITY_NOISE_STD_DEV
    CMD_EF_PRESS_ALT_NOISE_STD_DEV = _mscl.MipTypes_CMD_EF_PRESS_ALT_NOISE_STD_DEV
    CMD_EF_HARD_IRON_OFFSET_PROCESS_NOISE = _mscl.MipTypes_CMD_EF_HARD_IRON_OFFSET_PROCESS_NOISE
    CMD_EF_SOFT_IRON_OFFSET_PROCESS_NOISE = _mscl.MipTypes_CMD_EF_SOFT_IRON_OFFSET_PROCESS_NOISE
    CMD_EF_MAG_NOISE_STD_DEV = _mscl.MipTypes_CMD_EF_MAG_NOISE_STD_DEV
    CMD_EF_DECLINATION_SRC = _mscl.MipTypes_CMD_EF_DECLINATION_SRC
    CMD_EF_GRAV_MAGNITUDE_ERR_ADAPT_MEASURE = _mscl.MipTypes_CMD_EF_GRAV_MAGNITUDE_ERR_ADAPT_MEASURE
    CMD_EF_MAG_MAGNITUDE_ERR_ADAPT_MEASURE = _mscl.MipTypes_CMD_EF_MAG_MAGNITUDE_ERR_ADAPT_MEASURE
    CMD_EF_MAG_DIP_ANGLE_ERR_ADAPT_MEASURE = _mscl.MipTypes_CMD_EF_MAG_DIP_ANGLE_ERR_ADAPT_MEASURE
    CMD_EF_ALTITUDE_AID_CTRL = _mscl.MipTypes_CMD_EF_ALTITUDE_AID_CTRL
    CMD_EF_PITCH_ROLL_AID_CTRL = _mscl.MipTypes_CMD_EF_PITCH_ROLL_AID_CTRL
    CMD_EF_INCLINATION_SRC = _mscl.MipTypes_CMD_EF_INCLINATION_SRC
    CMD_EF_FIELD_MAGNITUDE_SRC = _mscl.MipTypes_CMD_EF_FIELD_MAGNITUDE_SRC
    CMD_COMMUNICATION_MODE = _mscl.MipTypes_CMD_COMMUNICATION_MODE
    CMD_HARDWARE_CTRL = _mscl.MipTypes_CMD_HARDWARE_CTRL
    CMD_GET_ANALOG_DISPLACEMENT_CALS = _mscl.MipTypes_CMD_GET_ANALOG_DISPLACEMENT_CALS
    CMD_DISPLACEMENT_OUTPUT_RATE = _mscl.MipTypes_CMD_DISPLACEMENT_OUTPUT_RATE
    CMD_DISPLACEMENT_DEVICE_TIME = _mscl.MipTypes_CMD_DISPLACEMENT_DEVICE_TIME
    CH_FIELD_SENSOR_RAW_ACCEL_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_RAW_ACCEL_VEC
    CH_FIELD_SENSOR_RAW_GYRO_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_RAW_GYRO_VEC
    CH_FIELD_SENSOR_RAW_MAG_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_RAW_MAG_VEC
    CH_FIELD_SENSOR_SCALED_ACCEL_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_SCALED_ACCEL_VEC
    CH_FIELD_SENSOR_SCALED_GYRO_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_SCALED_GYRO_VEC
    CH_FIELD_SENSOR_SCALED_MAG_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_SCALED_MAG_VEC
    CH_FIELD_SENSOR_DELTA_THETA_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_DELTA_THETA_VEC
    CH_FIELD_SENSOR_DELTA_VELOCITY_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_DELTA_VELOCITY_VEC
    CH_FIELD_SENSOR_ORIENTATION_MATRIX = _mscl.MipTypes_CH_FIELD_SENSOR_ORIENTATION_MATRIX
    CH_FIELD_SENSOR_ORIENTATION_QUATERNION = _mscl.MipTypes_CH_FIELD_SENSOR_ORIENTATION_QUATERNION
    CH_FIELD_SENSOR_ORIENTATION_UPDATE_MATRIX = _mscl.MipTypes_CH_FIELD_SENSOR_ORIENTATION_UPDATE_MATRIX
    CH_FIELD_SENSOR_EULER_ANGLES = _mscl.MipTypes_CH_FIELD_SENSOR_EULER_ANGLES
    CH_FIELD_SENSOR_INTERNAL_TIMESTAMP = _mscl.MipTypes_CH_FIELD_SENSOR_INTERNAL_TIMESTAMP
    CH_FIELD_SENSOR_BEACONED_TIMESTAMP = _mscl.MipTypes_CH_FIELD_SENSOR_BEACONED_TIMESTAMP
    CH_FIELD_SENSOR_STABILIZED_MAG_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_STABILIZED_MAG_VEC
    CH_FIELD_SENSOR_STABILIZED_ACCEL_VEC = _mscl.MipTypes_CH_FIELD_SENSOR_STABILIZED_ACCEL_VEC
    CH_FIELD_SENSOR_GPS_CORRELATION_TIMESTAMP = _mscl.MipTypes_CH_FIELD_SENSOR_GPS_CORRELATION_TIMESTAMP
    CH_FIELD_SENSOR_SCALED_AMBIENT_PRESSURE = _mscl.MipTypes_CH_FIELD_SENSOR_SCALED_AMBIENT_PRESSURE
    CH_FIELD_GNSS_LLH_POSITION = _mscl.MipTypes_CH_FIELD_GNSS_LLH_POSITION
    CH_FIELD_GNSS_ECEF_POSITION = _mscl.MipTypes_CH_FIELD_GNSS_ECEF_POSITION
    CH_FIELD_GNSS_NED_VELOCITY = _mscl.MipTypes_CH_FIELD_GNSS_NED_VELOCITY
    CH_FIELD_GNSS_ECEF_VELOCITY = _mscl.MipTypes_CH_FIELD_GNSS_ECEF_VELOCITY
    CH_FIELD_GNSS_DOP = _mscl.MipTypes_CH_FIELD_GNSS_DOP
    CH_FIELD_GNSS_UTC_TIME = _mscl.MipTypes_CH_FIELD_GNSS_UTC_TIME
    CH_FIELD_GNSS_GPS_TIME = _mscl.MipTypes_CH_FIELD_GNSS_GPS_TIME
    CH_FIELD_GNSS_CLOCK_INFO = _mscl.MipTypes_CH_FIELD_GNSS_CLOCK_INFO
    CH_FIELD_GNSS_FIX_INFO = _mscl.MipTypes_CH_FIELD_GNSS_FIX_INFO
    CH_FIELD_GNSS_SPACE_VEHICLE_INFO = _mscl.MipTypes_CH_FIELD_GNSS_SPACE_VEHICLE_INFO
    CH_FIELD_GNSS_HARDWARE_STATUS = _mscl.MipTypes_CH_FIELD_GNSS_HARDWARE_STATUS
    CH_FIELD_GNSS_DGNSS_INFO = _mscl.MipTypes_CH_FIELD_GNSS_DGNSS_INFO
    CH_FIELD_GNSS_DGNSS_CHANNEL_STATUS = _mscl.MipTypes_CH_FIELD_GNSS_DGNSS_CHANNEL_STATUS
    CH_FIELD_ESTFILTER_ESTIMATED_LLH_POS = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_LLH_POS
    CH_FIELD_ESTFILTER_ESTIMATED_NED_VELOCITY = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_NED_VELOCITY
    CH_FIELD_ESTFILTER_ESTIMATED_ORIENT_QUATERNION = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ORIENT_QUATERNION
    CH_FIELD_ESTFILTER_ESTIMATED_ORIENT_MATRIX = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ORIENT_MATRIX
    CH_FIELD_ESTFILTER_ESTIMATED_ORIENT_EULER = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ORIENT_EULER
    CH_FIELD_ESTFILTER_ESTIMATED_GYRO_BIAS = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_GYRO_BIAS
    CH_FIELD_ESTFILTER_ESTIMATED_ACCEL_BIAS = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ACCEL_BIAS
    CH_FIELD_ESTFILTER_ESTIMATED_LLH_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_LLH_UNCERT
    CH_FIELD_ESTFILTER_ESTIMATED_NED_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_NED_UNCERT
    CH_FIELD_ESTFILTER_ESTIMATED_ATT_UNCERT_EULER = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ATT_UNCERT_EULER
    CH_FIELD_ESTFILTER_ESTIMATED_GYRO_BIAS_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_GYRO_BIAS_UNCERT
    CH_FIELD_ESTFILTER_ESTIMATED_ACCEL_BIAS_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ACCEL_BIAS_UNCERT
    CH_FIELD_ESTFILTER_ESTIMATED_LINEAR_ACCEL = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_LINEAR_ACCEL
    CH_FIELD_ESTFILTER_ESTIMATED_ANGULAR_RATE = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ANGULAR_RATE
    CH_FIELD_ESTFILTER_WGS84_LOC_GRAV_MAGNITUDE = _mscl.MipTypes_CH_FIELD_ESTFILTER_WGS84_LOC_GRAV_MAGNITUDE
    CH_FIELD_ESTFILTER_FILTER_STATUS = _mscl.MipTypes_CH_FIELD_ESTFILTER_FILTER_STATUS
    CH_FIELD_ESTFILTER_GPS_TIMESTAMP = _mscl.MipTypes_CH_FIELD_ESTFILTER_GPS_TIMESTAMP
    CH_FIELD_ESTFILTER_ESTIMATED_ATT_UNCERT_QUAT = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_ATT_UNCERT_QUAT
    CH_FIELD_ESTFILTER_ESTIMATED_GRAVITY_VECTOR = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_GRAVITY_VECTOR
    CH_FIELD_ESTFILTER_HEADING_UPDATE_SOURCE = _mscl.MipTypes_CH_FIELD_ESTFILTER_HEADING_UPDATE_SOURCE
    CH_FIELD_ESTFILTER_MAGNETIC_MODEL_SLN = _mscl.MipTypes_CH_FIELD_ESTFILTER_MAGNETIC_MODEL_SLN
    CH_FIELD_ESTFILTER_ESTIMATED_GYRO_SCALE_FACTOR = _mscl.MipTypes_CH_FIELD_ESTFILTER_ESTIMATED_GYRO_SCALE_FACTOR
    CH_FIELD_ESTFILTER_ACCEL_SCALE_FACTOR = _mscl.MipTypes_CH_FIELD_ESTFILTER_ACCEL_SCALE_FACTOR
    CH_FIELD_ESTFILTER_GYRO_SCALE_FACTOR_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_GYRO_SCALE_FACTOR_UNCERT
    CH_FIELD_ESTFILTER_ACCEL_SCALE_FACTOR_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_ACCEL_SCALE_FACTOR_UNCERT
    CH_FIELD_ESTFILTER_COMPENSATED_ACCEL = _mscl.MipTypes_CH_FIELD_ESTFILTER_COMPENSATED_ACCEL
    CH_FIELD_ESTFILTER_STD_ATMOSPHERE_MODEL = _mscl.MipTypes_CH_FIELD_ESTFILTER_STD_ATMOSPHERE_MODEL
    CH_FIELD_ESTFILTER_PRESSURE_ALTITUDE = _mscl.MipTypes_CH_FIELD_ESTFILTER_PRESSURE_ALTITUDE
    CH_FIELD_ESTFILTER_MAG_AUTO_HARD_IRON_OFFSET = _mscl.MipTypes_CH_FIELD_ESTFILTER_MAG_AUTO_HARD_IRON_OFFSET
    CH_FIELD_ESTFILTER_MAG_AUTO_SOFT_IRON_MATRIX = _mscl.MipTypes_CH_FIELD_ESTFILTER_MAG_AUTO_SOFT_IRON_MATRIX
    CH_FIELD_ESTFILTER_MAG_AUTO_HARD_IRON_OFFSET_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_MAG_AUTO_HARD_IRON_OFFSET_UNCERT
    CH_FIELD_ESTFILTER_MAG_AUTO_SOFT_IRON_MATRIX_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_MAG_AUTO_SOFT_IRON_MATRIX_UNCERT
    CH_FIELD_ESTFILTER_GNSS_ANTENNA_CORRECTION = _mscl.MipTypes_CH_FIELD_ESTFILTER_GNSS_ANTENNA_CORRECTION
    CH_FIELD_ESTFILTER_GNSS_ANTENNA_CORRECTION_UNCERT = _mscl.MipTypes_CH_FIELD_ESTFILTER_GNSS_ANTENNA_CORRECTION_UNCERT
    CH_FIELD_DISP_DISPLACEMENT_RAW = _mscl.MipTypes_CH_FIELD_DISP_DISPLACEMENT_RAW
    CH_FIELD_DISP_DISPLACEMENT_MM = _mscl.MipTypes_CH_FIELD_DISP_DISPLACEMENT_MM
    CH_FIELD_DISP_DISPLACEMENT_TS = _mscl.MipTypes_CH_FIELD_DISP_DISPLACEMENT_TS
    CH_UNKNOWN = _mscl.MipTypes_CH_UNKNOWN
    CH_X = _mscl.MipTypes_CH_X
    CH_Y = _mscl.MipTypes_CH_Y
    CH_Z = _mscl.MipTypes_CH_Z
    CH_MATRIX = _mscl.MipTypes_CH_MATRIX
    CH_QUATERNION = _mscl.MipTypes_CH_QUATERNION
    CH_ROLL = _mscl.MipTypes_CH_ROLL
    CH_PITCH = _mscl.MipTypes_CH_PITCH
    CH_YAW = _mscl.MipTypes_CH_YAW
    CH_TICK = _mscl.MipTypes_CH_TICK
    CH_TIMESTAMP = _mscl.MipTypes_CH_TIMESTAMP
    CH_STATUS = _mscl.MipTypes_CH_STATUS
    CH_TIME_OF_WEEK = _mscl.MipTypes_CH_TIME_OF_WEEK
    CH_WEEK_NUMBER = _mscl.MipTypes_CH_WEEK_NUMBER
    CH_LATITUDE = _mscl.MipTypes_CH_LATITUDE
    CH_LONGITUDE = _mscl.MipTypes_CH_LONGITUDE
    CH_HEIGHT_ABOVE_ELLIPSOID = _mscl.MipTypes_CH_HEIGHT_ABOVE_ELLIPSOID
    CH_HEIGHT_ABOVE_MSL = _mscl.MipTypes_CH_HEIGHT_ABOVE_MSL
    CH_HORIZONTAL_ACCURACY = _mscl.MipTypes_CH_HORIZONTAL_ACCURACY
    CH_VERTICAL_ACCURACY = _mscl.MipTypes_CH_VERTICAL_ACCURACY
    CH_POSITION_ACCURACY = _mscl.MipTypes_CH_POSITION_ACCURACY
    CH_NORTH = _mscl.MipTypes_CH_NORTH
    CH_EAST = _mscl.MipTypes_CH_EAST
    CH_DOWN = _mscl.MipTypes_CH_DOWN
    CH_SPEED = _mscl.MipTypes_CH_SPEED
    CH_GROUND_SPEED = _mscl.MipTypes_CH_GROUND_SPEED
    CH_HEADING = _mscl.MipTypes_CH_HEADING
    CH_SPEED_ACCURACY = _mscl.MipTypes_CH_SPEED_ACCURACY
    CH_HEADING_ACCURACY = _mscl.MipTypes_CH_HEADING_ACCURACY
    CH_VELOCITY_ACCURACY = _mscl.MipTypes_CH_VELOCITY_ACCURACY
    CH_GEOMETRIC_DOP = _mscl.MipTypes_CH_GEOMETRIC_DOP
    CH_POSITION_DOP = _mscl.MipTypes_CH_POSITION_DOP
    CH_HORIZONTAL_DOP = _mscl.MipTypes_CH_HORIZONTAL_DOP
    CH_VERTICAL_DOP = _mscl.MipTypes_CH_VERTICAL_DOP
    CH_TIME_DOP = _mscl.MipTypes_CH_TIME_DOP
    CH_NORTHING_DOP = _mscl.MipTypes_CH_NORTHING_DOP
    CH_EASTING_DOP = _mscl.MipTypes_CH_EASTING_DOP
    CH_FLAGS = _mscl.MipTypes_CH_FLAGS
    CH_BIAS = _mscl.MipTypes_CH_BIAS
    CH_DRIFT = _mscl.MipTypes_CH_DRIFT
    CH_ACCURACY_ESTIMATE = _mscl.MipTypes_CH_ACCURACY_ESTIMATE
    CH_FIX_TYPE = _mscl.MipTypes_CH_FIX_TYPE
    CH_SV_COUNT = _mscl.MipTypes_CH_SV_COUNT
    CH_CHANNEL = _mscl.MipTypes_CH_CHANNEL
    CH_ID = _mscl.MipTypes_CH_ID
    CH_CARRIER_TO_NOISE_RATIO = _mscl.MipTypes_CH_CARRIER_TO_NOISE_RATIO
    CH_AZIMUTH = _mscl.MipTypes_CH_AZIMUTH
    CH_ELEVATION = _mscl.MipTypes_CH_ELEVATION
    CH_SENSOR_STATE = _mscl.MipTypes_CH_SENSOR_STATE
    CH_ANTENNA_STATE = _mscl.MipTypes_CH_ANTENNA_STATE
    CH_ANTENNA_POWER = _mscl.MipTypes_CH_ANTENNA_POWER
    CH_FILTER_STATE = _mscl.MipTypes_CH_FILTER_STATE
    CH_DYNAMICS_MODE = _mscl.MipTypes_CH_DYNAMICS_MODE
    CH_MAGNITUDE = _mscl.MipTypes_CH_MAGNITUDE
    CH_HEADING_UNCERTAINTY = _mscl.MipTypes_CH_HEADING_UNCERTAINTY
    CH_SOURCE = _mscl.MipTypes_CH_SOURCE
    CH_INCLINATION = _mscl.MipTypes_CH_INCLINATION
    CH_DECLINATION = _mscl.MipTypes_CH_DECLINATION
    CH_PRESSURE = _mscl.MipTypes_CH_PRESSURE
    CH_AGE = _mscl.MipTypes_CH_AGE
    CH_NUM_CHANNELS = _mscl.MipTypes_CH_NUM_CHANNELS
    CH_CORRECTION = _mscl.MipTypes_CH_CORRECTION
    CH_RATE_CORRECTION = _mscl.MipTypes_CH_RATE_CORRECTION
    CH_GEOMETRIC_ALTITUDE = _mscl.MipTypes_CH_GEOMETRIC_ALTITUDE
    CH_GEOPOTENTIAL_ALTITUDE = _mscl.MipTypes_CH_GEOPOTENTIAL_ALTITUDE
    CH_TEMPERATURE = _mscl.MipTypes_CH_TEMPERATURE
    CH_DENSITY = _mscl.MipTypes_CH_DENSITY
    CH_ALTITUDE = _mscl.MipTypes_CH_ALTITUDE
    CH_DISPLACEMENT = _mscl.MipTypes_CH_DISPLACEMENT
    channelName = staticmethod(_mscl.MipTypes_channelName)

    def __init__(self):
        this = _mscl.new_MipTypes()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_MipTypes
    __del__ = lambda self: None
MipTypes_swigregister = _mscl.MipTypes_swigregister
MipTypes_swigregister(MipTypes)

def MipTypes_channelName(field, qualifier):
    return _mscl.MipTypes_channelName(field, qualifier)
MipTypes_channelName = _mscl.MipTypes_channelName

class MipChannel(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_MipChannel(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def channelField(self):
        return _mscl.MipChannel_channelField(self)

    def sampleRate(self):
        return _mscl.MipChannel_sampleRate(self)

    def rateDecimation(self, sampleRateBase):
        return _mscl.MipChannel_rateDecimation(self, sampleRateBase)

    def validateSampleRate(self, *args):
        return _mscl.MipChannel_validateSampleRate(self, *args)
    __swig_destroy__ = _mscl.delete_MipChannel
    __del__ = lambda self: None
MipChannel_swigregister = _mscl.MipChannel_swigregister
MipChannel_swigregister(MipChannel)

class MipPacket(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MIP_ACK_NACK_ERROR_NONE = _mscl.MipPacket_MIP_ACK_NACK_ERROR_NONE
    MIP_ACK_NACK_ERROR_UNKNOWN_COMMAND = _mscl.MipPacket_MIP_ACK_NACK_ERROR_UNKNOWN_COMMAND
    MIP_ACK_NACK_ERROR_CHECKSUM_INVALID = _mscl.MipPacket_MIP_ACK_NACK_ERROR_CHECKSUM_INVALID
    MIP_ACK_NACK_ERROR_PARAMETER_INVALID = _mscl.MipPacket_MIP_ACK_NACK_ERROR_PARAMETER_INVALID
    MIP_ACK_NACK_ERROR_COMMAND_FAILED = _mscl.MipPacket_MIP_ACK_NACK_ERROR_COMMAND_FAILED
    MIP_ACK_NACK_ERROR_COMMAND_TIMEOUT = _mscl.MipPacket_MIP_ACK_NACK_ERROR_COMMAND_TIMEOUT
    MIP_ACK_NACK_ERROR_UNKNOWN_DESCRIPTOR_SET = _mscl.MipPacket_MIP_ACK_NACK_ERROR_UNKNOWN_DESCRIPTOR_SET

    def __init__(self):
        this = _mscl.new_MipPacket()
        try:
            self.this.append(this)
        except:
            self.this = this

    def isDataPacket(self):
        return _mscl.MipPacket_isDataPacket(self)

    def descriptorSet(self):
        return _mscl.MipPacket_descriptorSet(self)

    def payload(self):
        return _mscl.MipPacket_payload(self)
    __swig_destroy__ = _mscl.delete_MipPacket
    __del__ = lambda self: None
MipPacket_swigregister = _mscl.MipPacket_swigregister
MipPacket_swigregister(MipPacket)

class MipDataPoint(DataPoint):
    thisown = _swig_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

    def field(self):
        return _mscl.MipDataPoint_field(self)

    def qualifier(self):
        return _mscl.MipDataPoint_qualifier(self)

    def valid(self):
        return _mscl.MipDataPoint_valid(self)

    def channelName(self):
        return _mscl.MipDataPoint_channelName(self)
    __swig_destroy__ = _mscl.delete_MipDataPoint
    __del__ = lambda self: None
MipDataPoint_swigregister = _mscl.MipDataPoint_swigregister
MipDataPoint_swigregister(MipDataPoint)

class MipDataPacket(MipPacket):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_MipDataPacket(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def data(self):
        return _mscl.MipDataPacket_data(self)

    def collectedTimestamp(self):
        return _mscl.MipDataPacket_collectedTimestamp(self)

    def utcTimestamp(self):
        return _mscl.MipDataPacket_utcTimestamp(self)

    def utcTimeValid(self):
        return _mscl.MipDataPacket_utcTimeValid(self)

    def utcTimeFlags(self):
        return _mscl.MipDataPacket_utcTimeFlags(self)
    __swig_destroy__ = _mscl.delete_MipDataPacket
    __del__ = lambda self: None
MipDataPacket_swigregister = _mscl.MipDataPacket_swigregister
MipDataPacket_swigregister(MipDataPacket)

class MipNodeFeatures(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mscl.delete_MipNodeFeatures
    __del__ = lambda self: None

    def supportsCategory(self, dataClass):
        return _mscl.MipNodeFeatures_supportsCategory(self, dataClass)

    def supportsCommand(self, commandId):
        return _mscl.MipNodeFeatures_supportsCommand(self, commandId)

    def supportedCommands(self):
        return _mscl.MipNodeFeatures_supportedCommands(self)

    def supportedChannelFields(self, dataClass):
        return _mscl.MipNodeFeatures_supportedChannelFields(self, dataClass)

    def supportedSampleRates(self, dataClass):
        return _mscl.MipNodeFeatures_supportedSampleRates(self, dataClass)

    def supportedHeadingUpdateOptions(self):
        return _mscl.MipNodeFeatures_supportedHeadingUpdateOptions(self)

    def supportedEstimationControlOptions(self):
        return _mscl.MipNodeFeatures_supportedEstimationControlOptions(self)

    def supportedAdaptiveMeasurementModes(self):
        return _mscl.MipNodeFeatures_supportedAdaptiveMeasurementModes(self)
MipNodeFeatures_swigregister = _mscl.MipNodeFeatures_swigregister
MipNodeFeatures_swigregister(MipNodeFeatures)

class InertialNode(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, connection):
        this = _mscl.new_InertialNode(connection)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_InertialNode
    __del__ = lambda self: None
    deviceName = staticmethod(_mscl.InertialNode_deviceName)

    def connection(self):
        return _mscl.InertialNode_connection(self)

    def features(self):
        return _mscl.InertialNode_features(self)

    def lastCommunicationTime(self):
        return _mscl.InertialNode_lastCommunicationTime(self)

    def firmwareVersion(self):
        return _mscl.InertialNode_firmwareVersion(self)

    def model(self):
        return _mscl.InertialNode_model(self)

    def modelName(self):
        return _mscl.InertialNode_modelName(self)

    def modelNumber(self):
        return _mscl.InertialNode_modelNumber(self)

    def serialNumber(self):
        return _mscl.InertialNode_serialNumber(self)

    def lotNumber(self):
        return _mscl.InertialNode_lotNumber(self)

    def deviceOptions(self):
        return _mscl.InertialNode_deviceOptions(self)

    def getDataPackets(self, timeout=0, maxPackets=0):
        return _mscl.InertialNode_getDataPackets(self, timeout, maxPackets)

    def totalPackets(self):
        return _mscl.InertialNode_totalPackets(self)

    def timeout(self, *args):
        return _mscl.InertialNode_timeout(self, *args)

    def name(self):
        return _mscl.InertialNode_name(self)

    def ping(self):
        return _mscl.InertialNode_ping(self)

    def setToIdle(self):
        return _mscl.InertialNode_setToIdle(self)

    def cyclePower(self):
        return _mscl.InertialNode_cyclePower(self)

    def resume(self):
        return _mscl.InertialNode_resume(self)

    def saveSettingsAsStartup(self):
        return _mscl.InertialNode_saveSettingsAsStartup(self)

    def loadStartupSettings(self):
        return _mscl.InertialNode_loadStartupSettings(self)

    def loadFactoryDefaultSettings(self):
        return _mscl.InertialNode_loadFactoryDefaultSettings(self)

    def pollData(self, *args):
        return _mscl.InertialNode_pollData(self, *args)

    def getDataRateBase(self, dataClass):
        return _mscl.InertialNode_getDataRateBase(self, dataClass)

    def getActiveChannelFields(self, dataClass):
        return _mscl.InertialNode_getActiveChannelFields(self, dataClass)

    def setActiveChannelFields(self, dataClass, channels):
        return _mscl.InertialNode_setActiveChannelFields(self, dataClass, channels)

    def saveActiveChannelFields(self, dataClass):
        return _mscl.InertialNode_saveActiveChannelFields(self, dataClass)

    def getCommunicationMode(self):
        return _mscl.InertialNode_getCommunicationMode(self)

    def setCommunicationMode(self, communicationMode):
        return _mscl.InertialNode_setCommunicationMode(self, communicationMode)

    def enableDataStream(self, dataClass, enable=True):
        return _mscl.InertialNode_enableDataStream(self, dataClass, enable)

    def resetFilter(self):
        return _mscl.InertialNode_resetFilter(self)

    def getAutoInitialization(self):
        return _mscl.InertialNode_getAutoInitialization(self)

    def setAutoInitialization(self, enable):
        return _mscl.InertialNode_setAutoInitialization(self, enable)

    def getAltitudeAid(self):
        return _mscl.InertialNode_getAltitudeAid(self)

    def setAltitudeAid(self, enable):
        return _mscl.InertialNode_setAltitudeAid(self, enable)

    def getPitchRollAid(self):
        return _mscl.InertialNode_getPitchRollAid(self)

    def setPitchRollAid(self, enable):
        return _mscl.InertialNode_setPitchRollAid(self, enable)

    def setVelocityZUPT(self, ZUPTSettings):
        return _mscl.InertialNode_setVelocityZUPT(self, ZUPTSettings)

    def getVelocityZUPT(self):
        return _mscl.InertialNode_getVelocityZUPT(self)

    def setAngularRateZUPT(self, ZUPTSettings):
        return _mscl.InertialNode_setAngularRateZUPT(self, ZUPTSettings)

    def getAngularRateZUPT(self):
        return _mscl.InertialNode_getAngularRateZUPT(self)

    def setInitialAttitude(self, attitude):
        return _mscl.InertialNode_setInitialAttitude(self, attitude)

    def setInitialHeading(self, heading):
        return _mscl.InertialNode_setInitialHeading(self, heading)

    def getSensorToVehicleTransformation(self):
        return _mscl.InertialNode_getSensorToVehicleTransformation(self)

    def setSensorToVehicleTransformation(self, angles):
        return _mscl.InertialNode_setSensorToVehicleTransformation(self, angles)

    def getSensorToVehicleOffset(self):
        return _mscl.InertialNode_getSensorToVehicleOffset(self)

    def setSensorToVehicleOffset(self, offset):
        return _mscl.InertialNode_setSensorToVehicleOffset(self, offset)

    def getAntennaOffset(self):
        return _mscl.InertialNode_getAntennaOffset(self)

    def setAntennaOffset(self, offset):
        return _mscl.InertialNode_setAntennaOffset(self, offset)

    def getGNSSAssistedFixControl(self):
        return _mscl.InertialNode_getGNSSAssistedFixControl(self)

    def setGNSSAssistedFixControl(self, enableAssistedFix):
        return _mscl.InertialNode_setGNSSAssistedFixControl(self, enableAssistedFix)

    def getGNSSAssistTimeUpdate(self):
        return _mscl.InertialNode_getGNSSAssistTimeUpdate(self)

    def setGNSSAssistTimeUpdate(self, timeUpdate):
        return _mscl.InertialNode_setGNSSAssistTimeUpdate(self, timeUpdate)

    def getGPSTimeUpdate(self, timeFrame):
        return _mscl.InertialNode_getGPSTimeUpdate(self, timeFrame)

    def setGPSTimeUpdate(self, arg2, timeData):
        return _mscl.InertialNode_setGPSTimeUpdate(self, arg2, timeData)

    def setConstellationSettings(self, dataToUse):
        return _mscl.InertialNode_setConstellationSettings(self, dataToUse)

    def getConstellationSettings(self):
        return _mscl.InertialNode_getConstellationSettings(self)

    def setSBASSettings(self, dataToUse):
        return _mscl.InertialNode_setSBASSettings(self, dataToUse)

    def getSBASSettings(self):
        return _mscl.InertialNode_getSBASSettings(self)

    def setAccelerometerBias(self, biasVector):
        return _mscl.InertialNode_setAccelerometerBias(self, biasVector)

    def getAccelerometerBias(self):
        return _mscl.InertialNode_getAccelerometerBias(self)

    def setGyroBias(self, biasVector):
        return _mscl.InertialNode_setGyroBias(self, biasVector)

    def getGyroBias(self):
        return _mscl.InertialNode_getGyroBias(self)

    def captureGyroBias(self, samplingTime):
        return _mscl.InertialNode_captureGyroBias(self, samplingTime)

    def setMagnetometerSoftIronMatrix(self, matrix):
        return _mscl.InertialNode_setMagnetometerSoftIronMatrix(self, matrix)

    def getMagnetometerSoftIronMatrix(self):
        return _mscl.InertialNode_getMagnetometerSoftIronMatrix(self)

    def setMagnetometerHardIronOffset(self, offsetVector):
        return _mscl.InertialNode_setMagnetometerHardIronOffset(self, offsetVector)

    def getMagnetometerHardIronOffset(self):
        return _mscl.InertialNode_getMagnetometerHardIronOffset(self)

    def setConingAndScullingEnable(self, enable):
        return _mscl.InertialNode_setConingAndScullingEnable(self, enable)

    def getConingAndScullingEnable(self):
        return _mscl.InertialNode_getConingAndScullingEnable(self)

    def setUARTBaudRate(self, baudRate):
        return _mscl.InertialNode_setUARTBaudRate(self, baudRate)

    def getUARTBaudRate(self):
        return _mscl.InertialNode_getUARTBaudRate(self)

    def setAdvancedLowPassFilterSettings(self, data):
        return _mscl.InertialNode_setAdvancedLowPassFilterSettings(self, data)

    def getAdvancedLowPassFilterSettings(self, data):
        return _mscl.InertialNode_getAdvancedLowPassFilterSettings(self, data)

    def setComplementaryFilterSettings(self, data):
        return _mscl.InertialNode_setComplementaryFilterSettings(self, data)

    def getComplementaryFilterSettings(self):
        return _mscl.InertialNode_getComplementaryFilterSettings(self)

    def getBasicDeviceStatus(self):
        return _mscl.InertialNode_getBasicDeviceStatus(self)

    def getDiagnosticDeviceStatus(self):
        return _mscl.InertialNode_getDiagnosticDeviceStatus(self)

    def sendRawRTCM_2_3Message(self, theMessage):
        return _mscl.InertialNode_sendRawRTCM_2_3Message(self, theMessage)

    def setVehicleDynamicsMode(self, mode):
        return _mscl.InertialNode_setVehicleDynamicsMode(self, mode)

    def getVehicleDynamicsMode(self):
        return _mscl.InertialNode_getVehicleDynamicsMode(self)

    def setEstimationControlFlags(self, flags):
        return _mscl.InertialNode_setEstimationControlFlags(self, flags)

    def getEstimationControlFlags(self):
        return _mscl.InertialNode_getEstimationControlFlags(self)

    def setInclinationSource(self, options):
        return _mscl.InertialNode_setInclinationSource(self, options)

    def getInclinationSource(self):
        return _mscl.InertialNode_getInclinationSource(self)

    def setDeclinationSource(self, options):
        return _mscl.InertialNode_setDeclinationSource(self, options)

    def getDeclinationSource(self):
        return _mscl.InertialNode_getDeclinationSource(self)

    def setMagneticFieldMagnitudeSource(self, options):
        return _mscl.InertialNode_setMagneticFieldMagnitudeSource(self, options)

    def getMagneticFieldMagnitudeSource(self):
        return _mscl.InertialNode_getMagneticFieldMagnitudeSource(self)

    def setGNSS_SourceControl(self, gnssSource):
        return _mscl.InertialNode_setGNSS_SourceControl(self, gnssSource)

    def getGNSS_SourceControl(self):
        return _mscl.InertialNode_getGNSS_SourceControl(self)

    def sendExternalGNSSUpdate(self, gnssUpdateData):
        return _mscl.InertialNode_sendExternalGNSSUpdate(self, gnssUpdateData)

    def setHeadingUpdateControl(self, headingUpdateOptions):
        return _mscl.InertialNode_setHeadingUpdateControl(self, headingUpdateOptions)

    def getHeadingUpdateControl(self):
        return _mscl.InertialNode_getHeadingUpdateControl(self)

    def setGravityErrorAdaptiveMeasurement(self, data):
        return _mscl.InertialNode_setGravityErrorAdaptiveMeasurement(self, data)

    def getGravityErrorAdaptiveMeasurement(self):
        return _mscl.InertialNode_getGravityErrorAdaptiveMeasurement(self)

    def setMagnetometerErrorAdaptiveMeasurement(self, data):
        return _mscl.InertialNode_setMagnetometerErrorAdaptiveMeasurement(self, data)

    def getMagnetometerErrorAdaptiveMeasurement(self):
        return _mscl.InertialNode_getMagnetometerErrorAdaptiveMeasurement(self)

    def setMagDipAngleErrorAdaptiveMeasurement(self, data):
        return _mscl.InertialNode_setMagDipAngleErrorAdaptiveMeasurement(self, data)

    def getMagDipAngleErrorAdaptiveMeasurement(self):
        return _mscl.InertialNode_getMagDipAngleErrorAdaptiveMeasurement(self)

    def sendExternalHeadingUpdate(self, *args):
        return _mscl.InertialNode_sendExternalHeadingUpdate(self, *args)
InertialNode_swigregister = _mscl.InertialNode_swigregister
InertialNode_swigregister(InertialNode)

def InertialNode_deviceName(serial):
    return _mscl.InertialNode_deviceName(serial)
InertialNode_deviceName = _mscl.InertialNode_deviceName

class DisplacementNode(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, connection):
        this = _mscl.new_DisplacementNode(connection)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_DisplacementNode
    __del__ = lambda self: None

    def doCommand(self, descriptorSet, cmdDescriptor, fieldData, ackNackResponse, dataResponse, responseDataDescriptor=0):
        return _mscl.DisplacementNode_doCommand(self, descriptorSet, cmdDescriptor, fieldData, ackNackResponse, dataResponse, responseDataDescriptor)
    deviceName = staticmethod(_mscl.DisplacementNode_deviceName)

    def connection(self):
        return _mscl.DisplacementNode_connection(self)

    def features(self):
        return _mscl.DisplacementNode_features(self)

    def lastCommunicationTime(self):
        return _mscl.DisplacementNode_lastCommunicationTime(self)

    def firmwareVersion(self):
        return _mscl.DisplacementNode_firmwareVersion(self)

    def model(self):
        return _mscl.DisplacementNode_model(self)

    def modelName(self):
        return _mscl.DisplacementNode_modelName(self)

    def modelNumber(self):
        return _mscl.DisplacementNode_modelNumber(self)

    def serialNumber(self):
        return _mscl.DisplacementNode_serialNumber(self)

    def lotNumber(self):
        return _mscl.DisplacementNode_lotNumber(self)

    def deviceOptions(self):
        return _mscl.DisplacementNode_deviceOptions(self)

    def getDataPackets(self, timeout=0, maxPackets=0):
        return _mscl.DisplacementNode_getDataPackets(self, timeout, maxPackets)

    def totalPackets(self):
        return _mscl.DisplacementNode_totalPackets(self)

    def timeout(self, *args):
        return _mscl.DisplacementNode_timeout(self, *args)

    def name(self):
        return _mscl.DisplacementNode_name(self)

    def ping(self):
        return _mscl.DisplacementNode_ping(self)

    def setToIdle(self):
        return _mscl.DisplacementNode_setToIdle(self)

    def cyclePower(self):
        return _mscl.DisplacementNode_cyclePower(self)

    def resume(self):
        return _mscl.DisplacementNode_resume(self)

    def getDisplacementOutputDataRate(self):
        return _mscl.DisplacementNode_getDisplacementOutputDataRate(self)

    def getAnalogToDisplacementCal(self):
        return _mscl.DisplacementNode_getAnalogToDisplacementCal(self)

    def setDeviceTime(self, *args):
        return _mscl.DisplacementNode_setDeviceTime(self, *args)
DisplacementNode_swigregister = _mscl.DisplacementNode_swigregister
DisplacementNode_swigregister(DisplacementNode)

def DisplacementNode_deviceName(serial):
    return _mscl.DisplacementNode_deviceName(serial)
DisplacementNode_deviceName = _mscl.DisplacementNode_deviceName

class ChannelData(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.ChannelData_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.ChannelData___nonzero__(self)

    def __bool__(self):
        return _mscl.ChannelData___bool__(self)

    def __len__(self):
        return _mscl.ChannelData___len__(self)

    def pop(self):
        return _mscl.ChannelData_pop(self)

    def __getslice__(self, i, j):
        return _mscl.ChannelData___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.ChannelData___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.ChannelData___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.ChannelData___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.ChannelData___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.ChannelData___setitem__(self, *args)

    def append(self, x):
        return _mscl.ChannelData_append(self, x)

    def empty(self):
        return _mscl.ChannelData_empty(self)

    def size(self):
        return _mscl.ChannelData_size(self)

    def clear(self):
        return _mscl.ChannelData_clear(self)

    def swap(self, v):
        return _mscl.ChannelData_swap(self, v)

    def get_allocator(self):
        return _mscl.ChannelData_get_allocator(self)

    def begin(self):
        return _mscl.ChannelData_begin(self)

    def end(self):
        return _mscl.ChannelData_end(self)

    def rbegin(self):
        return _mscl.ChannelData_rbegin(self)

    def rend(self):
        return _mscl.ChannelData_rend(self)

    def pop_back(self):
        return _mscl.ChannelData_pop_back(self)

    def erase(self, *args):
        return _mscl.ChannelData_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_ChannelData(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.ChannelData_push_back(self, x)

    def front(self):
        return _mscl.ChannelData_front(self)

    def back(self):
        return _mscl.ChannelData_back(self)

    def assign(self, n, x):
        return _mscl.ChannelData_assign(self, n, x)

    def resize(self, *args):
        return _mscl.ChannelData_resize(self, *args)

    def insert(self, *args):
        return _mscl.ChannelData_insert(self, *args)

    def reserve(self, n):
        return _mscl.ChannelData_reserve(self, n)

    def capacity(self):
        return _mscl.ChannelData_capacity(self)
    __swig_destroy__ = _mscl.delete_ChannelData
    __del__ = lambda self: None
ChannelData_swigregister = _mscl.ChannelData_swigregister
ChannelData_swigregister(ChannelData)

class MipDataPoints(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.MipDataPoints_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.MipDataPoints___nonzero__(self)

    def __bool__(self):
        return _mscl.MipDataPoints___bool__(self)

    def __len__(self):
        return _mscl.MipDataPoints___len__(self)

    def pop(self):
        return _mscl.MipDataPoints_pop(self)

    def __getslice__(self, i, j):
        return _mscl.MipDataPoints___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.MipDataPoints___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.MipDataPoints___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.MipDataPoints___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.MipDataPoints___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.MipDataPoints___setitem__(self, *args)

    def append(self, x):
        return _mscl.MipDataPoints_append(self, x)

    def empty(self):
        return _mscl.MipDataPoints_empty(self)

    def size(self):
        return _mscl.MipDataPoints_size(self)

    def clear(self):
        return _mscl.MipDataPoints_clear(self)

    def swap(self, v):
        return _mscl.MipDataPoints_swap(self, v)

    def get_allocator(self):
        return _mscl.MipDataPoints_get_allocator(self)

    def begin(self):
        return _mscl.MipDataPoints_begin(self)

    def end(self):
        return _mscl.MipDataPoints_end(self)

    def rbegin(self):
        return _mscl.MipDataPoints_rbegin(self)

    def rend(self):
        return _mscl.MipDataPoints_rend(self)

    def pop_back(self):
        return _mscl.MipDataPoints_pop_back(self)

    def erase(self, *args):
        return _mscl.MipDataPoints_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_MipDataPoints(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.MipDataPoints_push_back(self, x)

    def front(self):
        return _mscl.MipDataPoints_front(self)

    def back(self):
        return _mscl.MipDataPoints_back(self)

    def assign(self, n, x):
        return _mscl.MipDataPoints_assign(self, n, x)

    def resize(self, *args):
        return _mscl.MipDataPoints_resize(self, *args)

    def insert(self, *args):
        return _mscl.MipDataPoints_insert(self, *args)

    def reserve(self, n):
        return _mscl.MipDataPoints_reserve(self, n)

    def capacity(self):
        return _mscl.MipDataPoints_capacity(self)
    __swig_destroy__ = _mscl.delete_MipDataPoints
    __del__ = lambda self: None
MipDataPoints_swigregister = _mscl.MipDataPoints_swigregister
MipDataPoints_swigregister(MipDataPoints)

class Bytes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.Bytes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.Bytes___nonzero__(self)

    def __bool__(self):
        return _mscl.Bytes___bool__(self)

    def __len__(self):
        return _mscl.Bytes___len__(self)

    def pop(self):
        return _mscl.Bytes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.Bytes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.Bytes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.Bytes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.Bytes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.Bytes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.Bytes___setitem__(self, *args)

    def append(self, x):
        return _mscl.Bytes_append(self, x)

    def empty(self):
        return _mscl.Bytes_empty(self)

    def size(self):
        return _mscl.Bytes_size(self)

    def clear(self):
        return _mscl.Bytes_clear(self)

    def swap(self, v):
        return _mscl.Bytes_swap(self, v)

    def get_allocator(self):
        return _mscl.Bytes_get_allocator(self)

    def begin(self):
        return _mscl.Bytes_begin(self)

    def end(self):
        return _mscl.Bytes_end(self)

    def rbegin(self):
        return _mscl.Bytes_rbegin(self)

    def rend(self):
        return _mscl.Bytes_rend(self)

    def pop_back(self):
        return _mscl.Bytes_pop_back(self)

    def erase(self, *args):
        return _mscl.Bytes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_Bytes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.Bytes_push_back(self, x)

    def front(self):
        return _mscl.Bytes_front(self)

    def back(self):
        return _mscl.Bytes_back(self)

    def assign(self, n, x):
        return _mscl.Bytes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.Bytes_resize(self, *args)

    def insert(self, *args):
        return _mscl.Bytes_insert(self, *args)

    def reserve(self, n):
        return _mscl.Bytes_reserve(self, n)

    def capacity(self):
        return _mscl.Bytes_capacity(self)
    __swig_destroy__ = _mscl.delete_Bytes
    __del__ = lambda self: None
Bytes_swigregister = _mscl.Bytes_swigregister
Bytes_swigregister(Bytes)

class DeviceList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DeviceList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DeviceList___nonzero__(self)

    def __bool__(self):
        return _mscl.DeviceList___bool__(self)

    def __len__(self):
        return _mscl.DeviceList___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 _mscl.DeviceList___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.DeviceList___delitem__(self, key)

    def has_key(self, key):
        return _mscl.DeviceList_has_key(self, key)

    def keys(self):
        return _mscl.DeviceList_keys(self)

    def values(self):
        return _mscl.DeviceList_values(self)

    def items(self):
        return _mscl.DeviceList_items(self)

    def __contains__(self, key):
        return _mscl.DeviceList___contains__(self, key)

    def key_iterator(self):
        return _mscl.DeviceList_key_iterator(self)

    def value_iterator(self):
        return _mscl.DeviceList_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.DeviceList___setitem__(self, *args)

    def asdict(self):
        return _mscl.DeviceList_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_DeviceList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.DeviceList_empty(self)

    def size(self):
        return _mscl.DeviceList_size(self)

    def clear(self):
        return _mscl.DeviceList_clear(self)

    def swap(self, v):
        return _mscl.DeviceList_swap(self, v)

    def get_allocator(self):
        return _mscl.DeviceList_get_allocator(self)

    def begin(self):
        return _mscl.DeviceList_begin(self)

    def end(self):
        return _mscl.DeviceList_end(self)

    def rbegin(self):
        return _mscl.DeviceList_rbegin(self)

    def rend(self):
        return _mscl.DeviceList_rend(self)

    def count(self, x):
        return _mscl.DeviceList_count(self, x)

    def erase(self, *args):
        return _mscl.DeviceList_erase(self, *args)

    def find(self, x):
        return _mscl.DeviceList_find(self, x)

    def lower_bound(self, x):
        return _mscl.DeviceList_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.DeviceList_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_DeviceList
    __del__ = lambda self: None
DeviceList_swigregister = _mscl.DeviceList_swigregister
DeviceList_swigregister(DeviceList)

class NodeDiscoveries(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.NodeDiscoveries_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.NodeDiscoveries___nonzero__(self)

    def __bool__(self):
        return _mscl.NodeDiscoveries___bool__(self)

    def __len__(self):
        return _mscl.NodeDiscoveries___len__(self)

    def pop(self):
        return _mscl.NodeDiscoveries_pop(self)

    def __getslice__(self, i, j):
        return _mscl.NodeDiscoveries___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.NodeDiscoveries___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.NodeDiscoveries___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.NodeDiscoveries___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.NodeDiscoveries___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.NodeDiscoveries___setitem__(self, *args)

    def append(self, x):
        return _mscl.NodeDiscoveries_append(self, x)

    def empty(self):
        return _mscl.NodeDiscoveries_empty(self)

    def size(self):
        return _mscl.NodeDiscoveries_size(self)

    def clear(self):
        return _mscl.NodeDiscoveries_clear(self)

    def swap(self, v):
        return _mscl.NodeDiscoveries_swap(self, v)

    def get_allocator(self):
        return _mscl.NodeDiscoveries_get_allocator(self)

    def begin(self):
        return _mscl.NodeDiscoveries_begin(self)

    def end(self):
        return _mscl.NodeDiscoveries_end(self)

    def rbegin(self):
        return _mscl.NodeDiscoveries_rbegin(self)

    def rend(self):
        return _mscl.NodeDiscoveries_rend(self)

    def pop_back(self):
        return _mscl.NodeDiscoveries_pop_back(self)

    def erase(self, *args):
        return _mscl.NodeDiscoveries_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_NodeDiscoveries(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.NodeDiscoveries_push_back(self, x)

    def front(self):
        return _mscl.NodeDiscoveries_front(self)

    def back(self):
        return _mscl.NodeDiscoveries_back(self)

    def assign(self, n, x):
        return _mscl.NodeDiscoveries_assign(self, n, x)

    def resize(self, *args):
        return _mscl.NodeDiscoveries_resize(self, *args)

    def insert(self, *args):
        return _mscl.NodeDiscoveries_insert(self, *args)

    def reserve(self, n):
        return _mscl.NodeDiscoveries_reserve(self, n)

    def capacity(self):
        return _mscl.NodeDiscoveries_capacity(self)
    __swig_destroy__ = _mscl.delete_NodeDiscoveries
    __del__ = lambda self: None
NodeDiscoveries_swigregister = _mscl.NodeDiscoveries_swigregister
NodeDiscoveries_swigregister(NodeDiscoveries)

class DataSweeps(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DataSweeps_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DataSweeps___nonzero__(self)

    def __bool__(self):
        return _mscl.DataSweeps___bool__(self)

    def __len__(self):
        return _mscl.DataSweeps___len__(self)

    def pop(self):
        return _mscl.DataSweeps_pop(self)

    def __getslice__(self, i, j):
        return _mscl.DataSweeps___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.DataSweeps___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.DataSweeps___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.DataSweeps___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.DataSweeps___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.DataSweeps___setitem__(self, *args)

    def append(self, x):
        return _mscl.DataSweeps_append(self, x)

    def empty(self):
        return _mscl.DataSweeps_empty(self)

    def size(self):
        return _mscl.DataSweeps_size(self)

    def clear(self):
        return _mscl.DataSweeps_clear(self)

    def swap(self, v):
        return _mscl.DataSweeps_swap(self, v)

    def get_allocator(self):
        return _mscl.DataSweeps_get_allocator(self)

    def begin(self):
        return _mscl.DataSweeps_begin(self)

    def end(self):
        return _mscl.DataSweeps_end(self)

    def rbegin(self):
        return _mscl.DataSweeps_rbegin(self)

    def rend(self):
        return _mscl.DataSweeps_rend(self)

    def pop_back(self):
        return _mscl.DataSweeps_pop_back(self)

    def erase(self, *args):
        return _mscl.DataSweeps_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_DataSweeps(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.DataSweeps_push_back(self, x)

    def front(self):
        return _mscl.DataSweeps_front(self)

    def back(self):
        return _mscl.DataSweeps_back(self)

    def assign(self, n, x):
        return _mscl.DataSweeps_assign(self, n, x)

    def resize(self, *args):
        return _mscl.DataSweeps_resize(self, *args)

    def insert(self, *args):
        return _mscl.DataSweeps_insert(self, *args)

    def reserve(self, n):
        return _mscl.DataSweeps_reserve(self, n)

    def capacity(self):
        return _mscl.DataSweeps_capacity(self)
    __swig_destroy__ = _mscl.delete_DataSweeps
    __del__ = lambda self: None
DataSweeps_swigregister = _mscl.DataSweeps_swigregister
DataSweeps_swigregister(DataSweeps)

class LoggedDataSweeps(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.LoggedDataSweeps_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.LoggedDataSweeps___nonzero__(self)

    def __bool__(self):
        return _mscl.LoggedDataSweeps___bool__(self)

    def __len__(self):
        return _mscl.LoggedDataSweeps___len__(self)

    def pop(self):
        return _mscl.LoggedDataSweeps_pop(self)

    def __getslice__(self, i, j):
        return _mscl.LoggedDataSweeps___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.LoggedDataSweeps___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.LoggedDataSweeps___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.LoggedDataSweeps___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.LoggedDataSweeps___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.LoggedDataSweeps___setitem__(self, *args)

    def append(self, x):
        return _mscl.LoggedDataSweeps_append(self, x)

    def empty(self):
        return _mscl.LoggedDataSweeps_empty(self)

    def size(self):
        return _mscl.LoggedDataSweeps_size(self)

    def clear(self):
        return _mscl.LoggedDataSweeps_clear(self)

    def swap(self, v):
        return _mscl.LoggedDataSweeps_swap(self, v)

    def get_allocator(self):
        return _mscl.LoggedDataSweeps_get_allocator(self)

    def begin(self):
        return _mscl.LoggedDataSweeps_begin(self)

    def end(self):
        return _mscl.LoggedDataSweeps_end(self)

    def rbegin(self):
        return _mscl.LoggedDataSweeps_rbegin(self)

    def rend(self):
        return _mscl.LoggedDataSweeps_rend(self)

    def pop_back(self):
        return _mscl.LoggedDataSweeps_pop_back(self)

    def erase(self, *args):
        return _mscl.LoggedDataSweeps_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_LoggedDataSweeps(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.LoggedDataSweeps_push_back(self, x)

    def front(self):
        return _mscl.LoggedDataSweeps_front(self)

    def back(self):
        return _mscl.LoggedDataSweeps_back(self)

    def assign(self, n, x):
        return _mscl.LoggedDataSweeps_assign(self, n, x)

    def resize(self, *args):
        return _mscl.LoggedDataSweeps_resize(self, *args)

    def insert(self, *args):
        return _mscl.LoggedDataSweeps_insert(self, *args)

    def reserve(self, n):
        return _mscl.LoggedDataSweeps_reserve(self, n)

    def capacity(self):
        return _mscl.LoggedDataSweeps_capacity(self)
    __swig_destroy__ = _mscl.delete_LoggedDataSweeps
    __del__ = lambda self: None
LoggedDataSweeps_swigregister = _mscl.LoggedDataSweeps_swigregister
LoggedDataSweeps_swigregister(LoggedDataSweeps)

class MipDataPackets(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.MipDataPackets_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.MipDataPackets___nonzero__(self)

    def __bool__(self):
        return _mscl.MipDataPackets___bool__(self)

    def __len__(self):
        return _mscl.MipDataPackets___len__(self)

    def pop(self):
        return _mscl.MipDataPackets_pop(self)

    def __getslice__(self, i, j):
        return _mscl.MipDataPackets___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.MipDataPackets___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.MipDataPackets___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.MipDataPackets___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.MipDataPackets___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.MipDataPackets___setitem__(self, *args)

    def append(self, x):
        return _mscl.MipDataPackets_append(self, x)

    def empty(self):
        return _mscl.MipDataPackets_empty(self)

    def size(self):
        return _mscl.MipDataPackets_size(self)

    def clear(self):
        return _mscl.MipDataPackets_clear(self)

    def swap(self, v):
        return _mscl.MipDataPackets_swap(self, v)

    def get_allocator(self):
        return _mscl.MipDataPackets_get_allocator(self)

    def begin(self):
        return _mscl.MipDataPackets_begin(self)

    def end(self):
        return _mscl.MipDataPackets_end(self)

    def rbegin(self):
        return _mscl.MipDataPackets_rbegin(self)

    def rend(self):
        return _mscl.MipDataPackets_rend(self)

    def pop_back(self):
        return _mscl.MipDataPackets_pop_back(self)

    def erase(self, *args):
        return _mscl.MipDataPackets_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_MipDataPackets(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.MipDataPackets_push_back(self, x)

    def front(self):
        return _mscl.MipDataPackets_front(self)

    def back(self):
        return _mscl.MipDataPackets_back(self)

    def assign(self, n, x):
        return _mscl.MipDataPackets_assign(self, n, x)

    def resize(self, *args):
        return _mscl.MipDataPackets_resize(self, *args)

    def insert(self, *args):
        return _mscl.MipDataPackets_insert(self, *args)

    def reserve(self, n):
        return _mscl.MipDataPackets_reserve(self, n)

    def capacity(self):
        return _mscl.MipDataPackets_capacity(self)
    __swig_destroy__ = _mscl.delete_MipDataPackets
    __del__ = lambda self: None
MipDataPackets_swigregister = _mscl.MipDataPackets_swigregister
MipDataPackets_swigregister(MipDataPackets)

class MipChannels(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.MipChannels_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.MipChannels___nonzero__(self)

    def __bool__(self):
        return _mscl.MipChannels___bool__(self)

    def __len__(self):
        return _mscl.MipChannels___len__(self)

    def pop(self):
        return _mscl.MipChannels_pop(self)

    def __getslice__(self, i, j):
        return _mscl.MipChannels___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.MipChannels___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.MipChannels___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.MipChannels___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.MipChannels___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.MipChannels___setitem__(self, *args)

    def append(self, x):
        return _mscl.MipChannels_append(self, x)

    def empty(self):
        return _mscl.MipChannels_empty(self)

    def size(self):
        return _mscl.MipChannels_size(self)

    def clear(self):
        return _mscl.MipChannels_clear(self)

    def swap(self, v):
        return _mscl.MipChannels_swap(self, v)

    def get_allocator(self):
        return _mscl.MipChannels_get_allocator(self)

    def begin(self):
        return _mscl.MipChannels_begin(self)

    def end(self):
        return _mscl.MipChannels_end(self)

    def rbegin(self):
        return _mscl.MipChannels_rbegin(self)

    def rend(self):
        return _mscl.MipChannels_rend(self)

    def pop_back(self):
        return _mscl.MipChannels_pop_back(self)

    def erase(self, *args):
        return _mscl.MipChannels_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_MipChannels(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.MipChannels_push_back(self, x)

    def front(self):
        return _mscl.MipChannels_front(self)

    def back(self):
        return _mscl.MipChannels_back(self)

    def assign(self, n, x):
        return _mscl.MipChannels_assign(self, n, x)

    def resize(self, *args):
        return _mscl.MipChannels_resize(self, *args)

    def insert(self, *args):
        return _mscl.MipChannels_insert(self, *args)

    def reserve(self, n):
        return _mscl.MipChannels_reserve(self, n)

    def capacity(self):
        return _mscl.MipChannels_capacity(self)
    __swig_destroy__ = _mscl.delete_MipChannels
    __del__ = lambda self: None
MipChannels_swigregister = _mscl.MipChannels_swigregister
MipChannels_swigregister(MipChannels)

class DataCollectionMethods(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DataCollectionMethods_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DataCollectionMethods___nonzero__(self)

    def __bool__(self):
        return _mscl.DataCollectionMethods___bool__(self)

    def __len__(self):
        return _mscl.DataCollectionMethods___len__(self)

    def pop(self):
        return _mscl.DataCollectionMethods_pop(self)

    def __getslice__(self, i, j):
        return _mscl.DataCollectionMethods___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.DataCollectionMethods___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.DataCollectionMethods___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.DataCollectionMethods___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.DataCollectionMethods___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.DataCollectionMethods___setitem__(self, *args)

    def append(self, x):
        return _mscl.DataCollectionMethods_append(self, x)

    def empty(self):
        return _mscl.DataCollectionMethods_empty(self)

    def size(self):
        return _mscl.DataCollectionMethods_size(self)

    def clear(self):
        return _mscl.DataCollectionMethods_clear(self)

    def swap(self, v):
        return _mscl.DataCollectionMethods_swap(self, v)

    def get_allocator(self):
        return _mscl.DataCollectionMethods_get_allocator(self)

    def begin(self):
        return _mscl.DataCollectionMethods_begin(self)

    def end(self):
        return _mscl.DataCollectionMethods_end(self)

    def rbegin(self):
        return _mscl.DataCollectionMethods_rbegin(self)

    def rend(self):
        return _mscl.DataCollectionMethods_rend(self)

    def pop_back(self):
        return _mscl.DataCollectionMethods_pop_back(self)

    def erase(self, *args):
        return _mscl.DataCollectionMethods_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_DataCollectionMethods(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.DataCollectionMethods_push_back(self, x)

    def front(self):
        return _mscl.DataCollectionMethods_front(self)

    def back(self):
        return _mscl.DataCollectionMethods_back(self)

    def assign(self, n, x):
        return _mscl.DataCollectionMethods_assign(self, n, x)

    def resize(self, *args):
        return _mscl.DataCollectionMethods_resize(self, *args)

    def insert(self, *args):
        return _mscl.DataCollectionMethods_insert(self, *args)

    def reserve(self, n):
        return _mscl.DataCollectionMethods_reserve(self, n)

    def capacity(self):
        return _mscl.DataCollectionMethods_capacity(self)
    __swig_destroy__ = _mscl.delete_DataCollectionMethods
    __del__ = lambda self: None
DataCollectionMethods_swigregister = _mscl.DataCollectionMethods_swigregister
DataCollectionMethods_swigregister(DataCollectionMethods)

class DataFormats(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DataFormats_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DataFormats___nonzero__(self)

    def __bool__(self):
        return _mscl.DataFormats___bool__(self)

    def __len__(self):
        return _mscl.DataFormats___len__(self)

    def pop(self):
        return _mscl.DataFormats_pop(self)

    def __getslice__(self, i, j):
        return _mscl.DataFormats___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.DataFormats___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.DataFormats___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.DataFormats___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.DataFormats___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.DataFormats___setitem__(self, *args)

    def append(self, x):
        return _mscl.DataFormats_append(self, x)

    def empty(self):
        return _mscl.DataFormats_empty(self)

    def size(self):
        return _mscl.DataFormats_size(self)

    def clear(self):
        return _mscl.DataFormats_clear(self)

    def swap(self, v):
        return _mscl.DataFormats_swap(self, v)

    def get_allocator(self):
        return _mscl.DataFormats_get_allocator(self)

    def begin(self):
        return _mscl.DataFormats_begin(self)

    def end(self):
        return _mscl.DataFormats_end(self)

    def rbegin(self):
        return _mscl.DataFormats_rbegin(self)

    def rend(self):
        return _mscl.DataFormats_rend(self)

    def pop_back(self):
        return _mscl.DataFormats_pop_back(self)

    def erase(self, *args):
        return _mscl.DataFormats_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_DataFormats(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.DataFormats_push_back(self, x)

    def front(self):
        return _mscl.DataFormats_front(self)

    def back(self):
        return _mscl.DataFormats_back(self)

    def assign(self, n, x):
        return _mscl.DataFormats_assign(self, n, x)

    def resize(self, *args):
        return _mscl.DataFormats_resize(self, *args)

    def insert(self, *args):
        return _mscl.DataFormats_insert(self, *args)

    def reserve(self, n):
        return _mscl.DataFormats_reserve(self, n)

    def capacity(self):
        return _mscl.DataFormats_capacity(self)
    __swig_destroy__ = _mscl.delete_DataFormats
    __del__ = lambda self: None
DataFormats_swigregister = _mscl.DataFormats_swigregister
DataFormats_swigregister(DataFormats)

class WirelessSampleRates(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.WirelessSampleRates_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.WirelessSampleRates___nonzero__(self)

    def __bool__(self):
        return _mscl.WirelessSampleRates___bool__(self)

    def __len__(self):
        return _mscl.WirelessSampleRates___len__(self)

    def pop(self):
        return _mscl.WirelessSampleRates_pop(self)

    def __getslice__(self, i, j):
        return _mscl.WirelessSampleRates___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.WirelessSampleRates___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.WirelessSampleRates___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.WirelessSampleRates___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.WirelessSampleRates___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.WirelessSampleRates___setitem__(self, *args)

    def append(self, x):
        return _mscl.WirelessSampleRates_append(self, x)

    def empty(self):
        return _mscl.WirelessSampleRates_empty(self)

    def size(self):
        return _mscl.WirelessSampleRates_size(self)

    def clear(self):
        return _mscl.WirelessSampleRates_clear(self)

    def swap(self, v):
        return _mscl.WirelessSampleRates_swap(self, v)

    def get_allocator(self):
        return _mscl.WirelessSampleRates_get_allocator(self)

    def begin(self):
        return _mscl.WirelessSampleRates_begin(self)

    def end(self):
        return _mscl.WirelessSampleRates_end(self)

    def rbegin(self):
        return _mscl.WirelessSampleRates_rbegin(self)

    def rend(self):
        return _mscl.WirelessSampleRates_rend(self)

    def pop_back(self):
        return _mscl.WirelessSampleRates_pop_back(self)

    def erase(self, *args):
        return _mscl.WirelessSampleRates_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_WirelessSampleRates(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.WirelessSampleRates_push_back(self, x)

    def front(self):
        return _mscl.WirelessSampleRates_front(self)

    def back(self):
        return _mscl.WirelessSampleRates_back(self)

    def assign(self, n, x):
        return _mscl.WirelessSampleRates_assign(self, n, x)

    def resize(self, *args):
        return _mscl.WirelessSampleRates_resize(self, *args)

    def insert(self, *args):
        return _mscl.WirelessSampleRates_insert(self, *args)

    def reserve(self, n):
        return _mscl.WirelessSampleRates_reserve(self, n)

    def capacity(self):
        return _mscl.WirelessSampleRates_capacity(self)
    __swig_destroy__ = _mscl.delete_WirelessSampleRates
    __del__ = lambda self: None
WirelessSampleRates_swigregister = _mscl.WirelessSampleRates_swigregister
WirelessSampleRates_swigregister(WirelessSampleRates)

class SamplingModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.SamplingModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.SamplingModes___nonzero__(self)

    def __bool__(self):
        return _mscl.SamplingModes___bool__(self)

    def __len__(self):
        return _mscl.SamplingModes___len__(self)

    def pop(self):
        return _mscl.SamplingModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.SamplingModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.SamplingModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.SamplingModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.SamplingModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.SamplingModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.SamplingModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.SamplingModes_append(self, x)

    def empty(self):
        return _mscl.SamplingModes_empty(self)

    def size(self):
        return _mscl.SamplingModes_size(self)

    def clear(self):
        return _mscl.SamplingModes_clear(self)

    def swap(self, v):
        return _mscl.SamplingModes_swap(self, v)

    def get_allocator(self):
        return _mscl.SamplingModes_get_allocator(self)

    def begin(self):
        return _mscl.SamplingModes_begin(self)

    def end(self):
        return _mscl.SamplingModes_end(self)

    def rbegin(self):
        return _mscl.SamplingModes_rbegin(self)

    def rend(self):
        return _mscl.SamplingModes_rend(self)

    def pop_back(self):
        return _mscl.SamplingModes_pop_back(self)

    def erase(self, *args):
        return _mscl.SamplingModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_SamplingModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.SamplingModes_push_back(self, x)

    def front(self):
        return _mscl.SamplingModes_front(self)

    def back(self):
        return _mscl.SamplingModes_back(self)

    def assign(self, n, x):
        return _mscl.SamplingModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.SamplingModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.SamplingModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.SamplingModes_reserve(self, n)

    def capacity(self):
        return _mscl.SamplingModes_capacity(self)
    __swig_destroy__ = _mscl.delete_SamplingModes
    __del__ = lambda self: None
SamplingModes_swigregister = _mscl.SamplingModes_swigregister
SamplingModes_swigregister(SamplingModes)

class DefaultModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DefaultModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DefaultModes___nonzero__(self)

    def __bool__(self):
        return _mscl.DefaultModes___bool__(self)

    def __len__(self):
        return _mscl.DefaultModes___len__(self)

    def pop(self):
        return _mscl.DefaultModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.DefaultModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.DefaultModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.DefaultModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.DefaultModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.DefaultModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.DefaultModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.DefaultModes_append(self, x)

    def empty(self):
        return _mscl.DefaultModes_empty(self)

    def size(self):
        return _mscl.DefaultModes_size(self)

    def clear(self):
        return _mscl.DefaultModes_clear(self)

    def swap(self, v):
        return _mscl.DefaultModes_swap(self, v)

    def get_allocator(self):
        return _mscl.DefaultModes_get_allocator(self)

    def begin(self):
        return _mscl.DefaultModes_begin(self)

    def end(self):
        return _mscl.DefaultModes_end(self)

    def rbegin(self):
        return _mscl.DefaultModes_rbegin(self)

    def rend(self):
        return _mscl.DefaultModes_rend(self)

    def pop_back(self):
        return _mscl.DefaultModes_pop_back(self)

    def erase(self, *args):
        return _mscl.DefaultModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_DefaultModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.DefaultModes_push_back(self, x)

    def front(self):
        return _mscl.DefaultModes_front(self)

    def back(self):
        return _mscl.DefaultModes_back(self)

    def assign(self, n, x):
        return _mscl.DefaultModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.DefaultModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.DefaultModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.DefaultModes_reserve(self, n)

    def capacity(self):
        return _mscl.DefaultModes_capacity(self)
    __swig_destroy__ = _mscl.delete_DefaultModes
    __del__ = lambda self: None
DefaultModes_swigregister = _mscl.DefaultModes_swigregister
DefaultModes_swigregister(DefaultModes)

class TransmitPowers(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.TransmitPowers_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.TransmitPowers___nonzero__(self)

    def __bool__(self):
        return _mscl.TransmitPowers___bool__(self)

    def __len__(self):
        return _mscl.TransmitPowers___len__(self)

    def pop(self):
        return _mscl.TransmitPowers_pop(self)

    def __getslice__(self, i, j):
        return _mscl.TransmitPowers___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.TransmitPowers___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.TransmitPowers___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.TransmitPowers___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.TransmitPowers___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.TransmitPowers___setitem__(self, *args)

    def append(self, x):
        return _mscl.TransmitPowers_append(self, x)

    def empty(self):
        return _mscl.TransmitPowers_empty(self)

    def size(self):
        return _mscl.TransmitPowers_size(self)

    def clear(self):
        return _mscl.TransmitPowers_clear(self)

    def swap(self, v):
        return _mscl.TransmitPowers_swap(self, v)

    def get_allocator(self):
        return _mscl.TransmitPowers_get_allocator(self)

    def begin(self):
        return _mscl.TransmitPowers_begin(self)

    def end(self):
        return _mscl.TransmitPowers_end(self)

    def rbegin(self):
        return _mscl.TransmitPowers_rbegin(self)

    def rend(self):
        return _mscl.TransmitPowers_rend(self)

    def pop_back(self):
        return _mscl.TransmitPowers_pop_back(self)

    def erase(self, *args):
        return _mscl.TransmitPowers_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_TransmitPowers(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.TransmitPowers_push_back(self, x)

    def front(self):
        return _mscl.TransmitPowers_front(self)

    def back(self):
        return _mscl.TransmitPowers_back(self)

    def assign(self, n, x):
        return _mscl.TransmitPowers_assign(self, n, x)

    def resize(self, *args):
        return _mscl.TransmitPowers_resize(self, *args)

    def insert(self, *args):
        return _mscl.TransmitPowers_insert(self, *args)

    def reserve(self, n):
        return _mscl.TransmitPowers_reserve(self, n)

    def capacity(self):
        return _mscl.TransmitPowers_capacity(self)
    __swig_destroy__ = _mscl.delete_TransmitPowers
    __del__ = lambda self: None
TransmitPowers_swigregister = _mscl.TransmitPowers_swigregister
TransmitPowers_swigregister(TransmitPowers)

class ChannelGroupSettings(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.ChannelGroupSettings_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.ChannelGroupSettings___nonzero__(self)

    def __bool__(self):
        return _mscl.ChannelGroupSettings___bool__(self)

    def __len__(self):
        return _mscl.ChannelGroupSettings___len__(self)

    def pop(self):
        return _mscl.ChannelGroupSettings_pop(self)

    def __getslice__(self, i, j):
        return _mscl.ChannelGroupSettings___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.ChannelGroupSettings___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.ChannelGroupSettings___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.ChannelGroupSettings___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.ChannelGroupSettings___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.ChannelGroupSettings___setitem__(self, *args)

    def append(self, x):
        return _mscl.ChannelGroupSettings_append(self, x)

    def empty(self):
        return _mscl.ChannelGroupSettings_empty(self)

    def size(self):
        return _mscl.ChannelGroupSettings_size(self)

    def clear(self):
        return _mscl.ChannelGroupSettings_clear(self)

    def swap(self, v):
        return _mscl.ChannelGroupSettings_swap(self, v)

    def get_allocator(self):
        return _mscl.ChannelGroupSettings_get_allocator(self)

    def begin(self):
        return _mscl.ChannelGroupSettings_begin(self)

    def end(self):
        return _mscl.ChannelGroupSettings_end(self)

    def rbegin(self):
        return _mscl.ChannelGroupSettings_rbegin(self)

    def rend(self):
        return _mscl.ChannelGroupSettings_rend(self)

    def pop_back(self):
        return _mscl.ChannelGroupSettings_pop_back(self)

    def erase(self, *args):
        return _mscl.ChannelGroupSettings_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_ChannelGroupSettings(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.ChannelGroupSettings_push_back(self, x)

    def front(self):
        return _mscl.ChannelGroupSettings_front(self)

    def back(self):
        return _mscl.ChannelGroupSettings_back(self)

    def assign(self, n, x):
        return _mscl.ChannelGroupSettings_assign(self, n, x)

    def resize(self, *args):
        return _mscl.ChannelGroupSettings_resize(self, *args)

    def insert(self, *args):
        return _mscl.ChannelGroupSettings_insert(self, *args)

    def reserve(self, n):
        return _mscl.ChannelGroupSettings_reserve(self, n)

    def capacity(self):
        return _mscl.ChannelGroupSettings_capacity(self)
    __swig_destroy__ = _mscl.delete_ChannelGroupSettings
    __del__ = lambda self: None
ChannelGroupSettings_swigregister = _mscl.ChannelGroupSettings_swigregister
ChannelGroupSettings_swigregister(ChannelGroupSettings)

class FatigueModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.FatigueModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.FatigueModes___nonzero__(self)

    def __bool__(self):
        return _mscl.FatigueModes___bool__(self)

    def __len__(self):
        return _mscl.FatigueModes___len__(self)

    def pop(self):
        return _mscl.FatigueModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.FatigueModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.FatigueModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.FatigueModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.FatigueModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.FatigueModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.FatigueModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.FatigueModes_append(self, x)

    def empty(self):
        return _mscl.FatigueModes_empty(self)

    def size(self):
        return _mscl.FatigueModes_size(self)

    def clear(self):
        return _mscl.FatigueModes_clear(self)

    def swap(self, v):
        return _mscl.FatigueModes_swap(self, v)

    def get_allocator(self):
        return _mscl.FatigueModes_get_allocator(self)

    def begin(self):
        return _mscl.FatigueModes_begin(self)

    def end(self):
        return _mscl.FatigueModes_end(self)

    def rbegin(self):
        return _mscl.FatigueModes_rbegin(self)

    def rend(self):
        return _mscl.FatigueModes_rend(self)

    def pop_back(self):
        return _mscl.FatigueModes_pop_back(self)

    def erase(self, *args):
        return _mscl.FatigueModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_FatigueModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.FatigueModes_push_back(self, x)

    def front(self):
        return _mscl.FatigueModes_front(self)

    def back(self):
        return _mscl.FatigueModes_back(self)

    def assign(self, n, x):
        return _mscl.FatigueModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.FatigueModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.FatigueModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.FatigueModes_reserve(self, n)

    def capacity(self):
        return _mscl.FatigueModes_capacity(self)
    __swig_destroy__ = _mscl.delete_FatigueModes
    __del__ = lambda self: None
FatigueModes_swigregister = _mscl.FatigueModes_swigregister
FatigueModes_swigregister(FatigueModes)

class Filters(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.Filters_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.Filters___nonzero__(self)

    def __bool__(self):
        return _mscl.Filters___bool__(self)

    def __len__(self):
        return _mscl.Filters___len__(self)

    def pop(self):
        return _mscl.Filters_pop(self)

    def __getslice__(self, i, j):
        return _mscl.Filters___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.Filters___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.Filters___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.Filters___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.Filters___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.Filters___setitem__(self, *args)

    def append(self, x):
        return _mscl.Filters_append(self, x)

    def empty(self):
        return _mscl.Filters_empty(self)

    def size(self):
        return _mscl.Filters_size(self)

    def clear(self):
        return _mscl.Filters_clear(self)

    def swap(self, v):
        return _mscl.Filters_swap(self, v)

    def get_allocator(self):
        return _mscl.Filters_get_allocator(self)

    def begin(self):
        return _mscl.Filters_begin(self)

    def end(self):
        return _mscl.Filters_end(self)

    def rbegin(self):
        return _mscl.Filters_rbegin(self)

    def rend(self):
        return _mscl.Filters_rend(self)

    def pop_back(self):
        return _mscl.Filters_pop_back(self)

    def erase(self, *args):
        return _mscl.Filters_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_Filters(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.Filters_push_back(self, x)

    def front(self):
        return _mscl.Filters_front(self)

    def back(self):
        return _mscl.Filters_back(self)

    def assign(self, n, x):
        return _mscl.Filters_assign(self, n, x)

    def resize(self, *args):
        return _mscl.Filters_resize(self, *args)

    def insert(self, *args):
        return _mscl.Filters_insert(self, *args)

    def reserve(self, n):
        return _mscl.Filters_reserve(self, n)

    def capacity(self):
        return _mscl.Filters_capacity(self)
    __swig_destroy__ = _mscl.delete_Filters
    __del__ = lambda self: None
Filters_swigregister = _mscl.Filters_swigregister
Filters_swigregister(Filters)

class HighPassFilters(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.HighPassFilters_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.HighPassFilters___nonzero__(self)

    def __bool__(self):
        return _mscl.HighPassFilters___bool__(self)

    def __len__(self):
        return _mscl.HighPassFilters___len__(self)

    def pop(self):
        return _mscl.HighPassFilters_pop(self)

    def __getslice__(self, i, j):
        return _mscl.HighPassFilters___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.HighPassFilters___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.HighPassFilters___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.HighPassFilters___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.HighPassFilters___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.HighPassFilters___setitem__(self, *args)

    def append(self, x):
        return _mscl.HighPassFilters_append(self, x)

    def empty(self):
        return _mscl.HighPassFilters_empty(self)

    def size(self):
        return _mscl.HighPassFilters_size(self)

    def clear(self):
        return _mscl.HighPassFilters_clear(self)

    def swap(self, v):
        return _mscl.HighPassFilters_swap(self, v)

    def get_allocator(self):
        return _mscl.HighPassFilters_get_allocator(self)

    def begin(self):
        return _mscl.HighPassFilters_begin(self)

    def end(self):
        return _mscl.HighPassFilters_end(self)

    def rbegin(self):
        return _mscl.HighPassFilters_rbegin(self)

    def rend(self):
        return _mscl.HighPassFilters_rend(self)

    def pop_back(self):
        return _mscl.HighPassFilters_pop_back(self)

    def erase(self, *args):
        return _mscl.HighPassFilters_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_HighPassFilters(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.HighPassFilters_push_back(self, x)

    def front(self):
        return _mscl.HighPassFilters_front(self)

    def back(self):
        return _mscl.HighPassFilters_back(self)

    def assign(self, n, x):
        return _mscl.HighPassFilters_assign(self, n, x)

    def resize(self, *args):
        return _mscl.HighPassFilters_resize(self, *args)

    def insert(self, *args):
        return _mscl.HighPassFilters_insert(self, *args)

    def reserve(self, n):
        return _mscl.HighPassFilters_reserve(self, n)

    def capacity(self):
        return _mscl.HighPassFilters_capacity(self)
    __swig_destroy__ = _mscl.delete_HighPassFilters
    __del__ = lambda self: None
HighPassFilters_swigregister = _mscl.HighPassFilters_swigregister
HighPassFilters_swigregister(HighPassFilters)

class StorageLimitModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.StorageLimitModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.StorageLimitModes___nonzero__(self)

    def __bool__(self):
        return _mscl.StorageLimitModes___bool__(self)

    def __len__(self):
        return _mscl.StorageLimitModes___len__(self)

    def pop(self):
        return _mscl.StorageLimitModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.StorageLimitModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.StorageLimitModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.StorageLimitModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.StorageLimitModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.StorageLimitModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.StorageLimitModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.StorageLimitModes_append(self, x)

    def empty(self):
        return _mscl.StorageLimitModes_empty(self)

    def size(self):
        return _mscl.StorageLimitModes_size(self)

    def clear(self):
        return _mscl.StorageLimitModes_clear(self)

    def swap(self, v):
        return _mscl.StorageLimitModes_swap(self, v)

    def get_allocator(self):
        return _mscl.StorageLimitModes_get_allocator(self)

    def begin(self):
        return _mscl.StorageLimitModes_begin(self)

    def end(self):
        return _mscl.StorageLimitModes_end(self)

    def rbegin(self):
        return _mscl.StorageLimitModes_rbegin(self)

    def rend(self):
        return _mscl.StorageLimitModes_rend(self)

    def pop_back(self):
        return _mscl.StorageLimitModes_pop_back(self)

    def erase(self, *args):
        return _mscl.StorageLimitModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_StorageLimitModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.StorageLimitModes_push_back(self, x)

    def front(self):
        return _mscl.StorageLimitModes_front(self)

    def back(self):
        return _mscl.StorageLimitModes_back(self)

    def assign(self, n, x):
        return _mscl.StorageLimitModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.StorageLimitModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.StorageLimitModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.StorageLimitModes_reserve(self, n)

    def capacity(self):
        return _mscl.StorageLimitModes_capacity(self)
    __swig_destroy__ = _mscl.delete_StorageLimitModes
    __del__ = lambda self: None
StorageLimitModes_swigregister = _mscl.StorageLimitModes_swigregister
StorageLimitModes_swigregister(StorageLimitModes)

class InputRanges(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.InputRanges_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.InputRanges___nonzero__(self)

    def __bool__(self):
        return _mscl.InputRanges___bool__(self)

    def __len__(self):
        return _mscl.InputRanges___len__(self)

    def pop(self):
        return _mscl.InputRanges_pop(self)

    def __getslice__(self, i, j):
        return _mscl.InputRanges___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.InputRanges___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.InputRanges___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.InputRanges___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.InputRanges___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.InputRanges___setitem__(self, *args)

    def append(self, x):
        return _mscl.InputRanges_append(self, x)

    def empty(self):
        return _mscl.InputRanges_empty(self)

    def size(self):
        return _mscl.InputRanges_size(self)

    def clear(self):
        return _mscl.InputRanges_clear(self)

    def swap(self, v):
        return _mscl.InputRanges_swap(self, v)

    def get_allocator(self):
        return _mscl.InputRanges_get_allocator(self)

    def begin(self):
        return _mscl.InputRanges_begin(self)

    def end(self):
        return _mscl.InputRanges_end(self)

    def rbegin(self):
        return _mscl.InputRanges_rbegin(self)

    def rend(self):
        return _mscl.InputRanges_rend(self)

    def pop_back(self):
        return _mscl.InputRanges_pop_back(self)

    def erase(self, *args):
        return _mscl.InputRanges_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_InputRanges(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.InputRanges_push_back(self, x)

    def front(self):
        return _mscl.InputRanges_front(self)

    def back(self):
        return _mscl.InputRanges_back(self)

    def assign(self, n, x):
        return _mscl.InputRanges_assign(self, n, x)

    def resize(self, *args):
        return _mscl.InputRanges_resize(self, *args)

    def insert(self, *args):
        return _mscl.InputRanges_insert(self, *args)

    def reserve(self, n):
        return _mscl.InputRanges_reserve(self, n)

    def capacity(self):
        return _mscl.InputRanges_capacity(self)
    __swig_destroy__ = _mscl.delete_InputRanges
    __del__ = lambda self: None
InputRanges_swigregister = _mscl.InputRanges_swigregister
InputRanges_swigregister(InputRanges)

class DataModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DataModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DataModes___nonzero__(self)

    def __bool__(self):
        return _mscl.DataModes___bool__(self)

    def __len__(self):
        return _mscl.DataModes___len__(self)

    def pop(self):
        return _mscl.DataModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.DataModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.DataModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.DataModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.DataModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.DataModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.DataModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.DataModes_append(self, x)

    def empty(self):
        return _mscl.DataModes_empty(self)

    def size(self):
        return _mscl.DataModes_size(self)

    def clear(self):
        return _mscl.DataModes_clear(self)

    def swap(self, v):
        return _mscl.DataModes_swap(self, v)

    def get_allocator(self):
        return _mscl.DataModes_get_allocator(self)

    def begin(self):
        return _mscl.DataModes_begin(self)

    def end(self):
        return _mscl.DataModes_end(self)

    def rbegin(self):
        return _mscl.DataModes_rbegin(self)

    def rend(self):
        return _mscl.DataModes_rend(self)

    def pop_back(self):
        return _mscl.DataModes_pop_back(self)

    def erase(self, *args):
        return _mscl.DataModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_DataModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.DataModes_push_back(self, x)

    def front(self):
        return _mscl.DataModes_front(self)

    def back(self):
        return _mscl.DataModes_back(self)

    def assign(self, n, x):
        return _mscl.DataModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.DataModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.DataModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.DataModes_reserve(self, n)

    def capacity(self):
        return _mscl.DataModes_capacity(self)
    __swig_destroy__ = _mscl.delete_DataModes
    __del__ = lambda self: None
DataModes_swigregister = _mscl.DataModes_swigregister
DataModes_swigregister(DataModes)

class CommProtocols(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.CommProtocols_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.CommProtocols___nonzero__(self)

    def __bool__(self):
        return _mscl.CommProtocols___bool__(self)

    def __len__(self):
        return _mscl.CommProtocols___len__(self)

    def pop(self):
        return _mscl.CommProtocols_pop(self)

    def __getslice__(self, i, j):
        return _mscl.CommProtocols___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.CommProtocols___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.CommProtocols___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.CommProtocols___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.CommProtocols___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.CommProtocols___setitem__(self, *args)

    def append(self, x):
        return _mscl.CommProtocols_append(self, x)

    def empty(self):
        return _mscl.CommProtocols_empty(self)

    def size(self):
        return _mscl.CommProtocols_size(self)

    def clear(self):
        return _mscl.CommProtocols_clear(self)

    def swap(self, v):
        return _mscl.CommProtocols_swap(self, v)

    def get_allocator(self):
        return _mscl.CommProtocols_get_allocator(self)

    def begin(self):
        return _mscl.CommProtocols_begin(self)

    def end(self):
        return _mscl.CommProtocols_end(self)

    def rbegin(self):
        return _mscl.CommProtocols_rbegin(self)

    def rend(self):
        return _mscl.CommProtocols_rend(self)

    def pop_back(self):
        return _mscl.CommProtocols_pop_back(self)

    def erase(self, *args):
        return _mscl.CommProtocols_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_CommProtocols(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.CommProtocols_push_back(self, x)

    def front(self):
        return _mscl.CommProtocols_front(self)

    def back(self):
        return _mscl.CommProtocols_back(self)

    def assign(self, n, x):
        return _mscl.CommProtocols_assign(self, n, x)

    def resize(self, *args):
        return _mscl.CommProtocols_resize(self, *args)

    def insert(self, *args):
        return _mscl.CommProtocols_insert(self, *args)

    def reserve(self, n):
        return _mscl.CommProtocols_reserve(self, n)

    def capacity(self):
        return _mscl.CommProtocols_capacity(self)
    __swig_destroy__ = _mscl.delete_CommProtocols
    __del__ = lambda self: None
CommProtocols_swigregister = _mscl.CommProtocols_swigregister
CommProtocols_swigregister(CommProtocols)

class Voltages(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.Voltages_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.Voltages___nonzero__(self)

    def __bool__(self):
        return _mscl.Voltages___bool__(self)

    def __len__(self):
        return _mscl.Voltages___len__(self)

    def pop(self):
        return _mscl.Voltages_pop(self)

    def __getslice__(self, i, j):
        return _mscl.Voltages___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.Voltages___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.Voltages___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.Voltages___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.Voltages___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.Voltages___setitem__(self, *args)

    def append(self, x):
        return _mscl.Voltages_append(self, x)

    def empty(self):
        return _mscl.Voltages_empty(self)

    def size(self):
        return _mscl.Voltages_size(self)

    def clear(self):
        return _mscl.Voltages_clear(self)

    def swap(self, v):
        return _mscl.Voltages_swap(self, v)

    def get_allocator(self):
        return _mscl.Voltages_get_allocator(self)

    def begin(self):
        return _mscl.Voltages_begin(self)

    def end(self):
        return _mscl.Voltages_end(self)

    def rbegin(self):
        return _mscl.Voltages_rbegin(self)

    def rend(self):
        return _mscl.Voltages_rend(self)

    def pop_back(self):
        return _mscl.Voltages_pop_back(self)

    def erase(self, *args):
        return _mscl.Voltages_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_Voltages(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.Voltages_push_back(self, x)

    def front(self):
        return _mscl.Voltages_front(self)

    def back(self):
        return _mscl.Voltages_back(self)

    def assign(self, n, x):
        return _mscl.Voltages_assign(self, n, x)

    def resize(self, *args):
        return _mscl.Voltages_resize(self, *args)

    def insert(self, *args):
        return _mscl.Voltages_insert(self, *args)

    def reserve(self, n):
        return _mscl.Voltages_reserve(self, n)

    def capacity(self):
        return _mscl.Voltages_capacity(self)
    __swig_destroy__ = _mscl.delete_Voltages
    __del__ = lambda self: None
Voltages_swigregister = _mscl.Voltages_swigregister
Voltages_swigregister(Voltages)

class SensorOutputModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.SensorOutputModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.SensorOutputModes___nonzero__(self)

    def __bool__(self):
        return _mscl.SensorOutputModes___bool__(self)

    def __len__(self):
        return _mscl.SensorOutputModes___len__(self)

    def pop(self):
        return _mscl.SensorOutputModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.SensorOutputModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.SensorOutputModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.SensorOutputModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.SensorOutputModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.SensorOutputModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.SensorOutputModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.SensorOutputModes_append(self, x)

    def empty(self):
        return _mscl.SensorOutputModes_empty(self)

    def size(self):
        return _mscl.SensorOutputModes_size(self)

    def clear(self):
        return _mscl.SensorOutputModes_clear(self)

    def swap(self, v):
        return _mscl.SensorOutputModes_swap(self, v)

    def get_allocator(self):
        return _mscl.SensorOutputModes_get_allocator(self)

    def begin(self):
        return _mscl.SensorOutputModes_begin(self)

    def end(self):
        return _mscl.SensorOutputModes_end(self)

    def rbegin(self):
        return _mscl.SensorOutputModes_rbegin(self)

    def rend(self):
        return _mscl.SensorOutputModes_rend(self)

    def pop_back(self):
        return _mscl.SensorOutputModes_pop_back(self)

    def erase(self, *args):
        return _mscl.SensorOutputModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_SensorOutputModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.SensorOutputModes_push_back(self, x)

    def front(self):
        return _mscl.SensorOutputModes_front(self)

    def back(self):
        return _mscl.SensorOutputModes_back(self)

    def assign(self, n, x):
        return _mscl.SensorOutputModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.SensorOutputModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.SensorOutputModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.SensorOutputModes_reserve(self, n)

    def capacity(self):
        return _mscl.SensorOutputModes_capacity(self)
    __swig_destroy__ = _mscl.delete_SensorOutputModes
    __del__ = lambda self: None
SensorOutputModes_swigregister = _mscl.SensorOutputModes_swigregister
SensorOutputModes_swigregister(SensorOutputModes)

class DerivedCategories(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DerivedCategories_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DerivedCategories___nonzero__(self)

    def __bool__(self):
        return _mscl.DerivedCategories___bool__(self)

    def __len__(self):
        return _mscl.DerivedCategories___len__(self)

    def pop(self):
        return _mscl.DerivedCategories_pop(self)

    def __getslice__(self, i, j):
        return _mscl.DerivedCategories___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.DerivedCategories___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.DerivedCategories___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.DerivedCategories___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.DerivedCategories___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.DerivedCategories___setitem__(self, *args)

    def append(self, x):
        return _mscl.DerivedCategories_append(self, x)

    def empty(self):
        return _mscl.DerivedCategories_empty(self)

    def size(self):
        return _mscl.DerivedCategories_size(self)

    def clear(self):
        return _mscl.DerivedCategories_clear(self)

    def swap(self, v):
        return _mscl.DerivedCategories_swap(self, v)

    def get_allocator(self):
        return _mscl.DerivedCategories_get_allocator(self)

    def begin(self):
        return _mscl.DerivedCategories_begin(self)

    def end(self):
        return _mscl.DerivedCategories_end(self)

    def rbegin(self):
        return _mscl.DerivedCategories_rbegin(self)

    def rend(self):
        return _mscl.DerivedCategories_rend(self)

    def pop_back(self):
        return _mscl.DerivedCategories_pop_back(self)

    def erase(self, *args):
        return _mscl.DerivedCategories_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_DerivedCategories(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.DerivedCategories_push_back(self, x)

    def front(self):
        return _mscl.DerivedCategories_front(self)

    def back(self):
        return _mscl.DerivedCategories_back(self)

    def assign(self, n, x):
        return _mscl.DerivedCategories_assign(self, n, x)

    def resize(self, *args):
        return _mscl.DerivedCategories_resize(self, *args)

    def insert(self, *args):
        return _mscl.DerivedCategories_insert(self, *args)

    def reserve(self, n):
        return _mscl.DerivedCategories_reserve(self, n)

    def capacity(self):
        return _mscl.DerivedCategories_capacity(self)
    __swig_destroy__ = _mscl.delete_DerivedCategories
    __del__ = lambda self: None
DerivedCategories_swigregister = _mscl.DerivedCategories_swigregister
DerivedCategories_swigregister(DerivedCategories)

class EepromMap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.EepromMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.EepromMap___nonzero__(self)

    def __bool__(self):
        return _mscl.EepromMap___bool__(self)

    def __len__(self):
        return _mscl.EepromMap___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 _mscl.EepromMap___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.EepromMap___delitem__(self, key)

    def has_key(self, key):
        return _mscl.EepromMap_has_key(self, key)

    def keys(self):
        return _mscl.EepromMap_keys(self)

    def values(self):
        return _mscl.EepromMap_values(self)

    def items(self):
        return _mscl.EepromMap_items(self)

    def __contains__(self, key):
        return _mscl.EepromMap___contains__(self, key)

    def key_iterator(self):
        return _mscl.EepromMap_key_iterator(self)

    def value_iterator(self):
        return _mscl.EepromMap_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.EepromMap___setitem__(self, *args)

    def asdict(self):
        return _mscl.EepromMap_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_EepromMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.EepromMap_empty(self)

    def size(self):
        return _mscl.EepromMap_size(self)

    def clear(self):
        return _mscl.EepromMap_clear(self)

    def swap(self, v):
        return _mscl.EepromMap_swap(self, v)

    def get_allocator(self):
        return _mscl.EepromMap_get_allocator(self)

    def begin(self):
        return _mscl.EepromMap_begin(self)

    def end(self):
        return _mscl.EepromMap_end(self)

    def rbegin(self):
        return _mscl.EepromMap_rbegin(self)

    def rend(self):
        return _mscl.EepromMap_rend(self)

    def count(self, x):
        return _mscl.EepromMap_count(self, x)

    def erase(self, *args):
        return _mscl.EepromMap_erase(self, *args)

    def find(self, x):
        return _mscl.EepromMap_find(self, x)

    def lower_bound(self, x):
        return _mscl.EepromMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.EepromMap_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_EepromMap
    __del__ = lambda self: None
EepromMap_swigregister = _mscl.EepromMap_swigregister
EepromMap_swigregister(EepromMap)

class DerivedChannelMasks(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DerivedChannelMasks_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DerivedChannelMasks___nonzero__(self)

    def __bool__(self):
        return _mscl.DerivedChannelMasks___bool__(self)

    def __len__(self):
        return _mscl.DerivedChannelMasks___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 _mscl.DerivedChannelMasks___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.DerivedChannelMasks___delitem__(self, key)

    def has_key(self, key):
        return _mscl.DerivedChannelMasks_has_key(self, key)

    def keys(self):
        return _mscl.DerivedChannelMasks_keys(self)

    def values(self):
        return _mscl.DerivedChannelMasks_values(self)

    def items(self):
        return _mscl.DerivedChannelMasks_items(self)

    def __contains__(self, key):
        return _mscl.DerivedChannelMasks___contains__(self, key)

    def key_iterator(self):
        return _mscl.DerivedChannelMasks_key_iterator(self)

    def value_iterator(self):
        return _mscl.DerivedChannelMasks_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.DerivedChannelMasks___setitem__(self, *args)

    def asdict(self):
        return _mscl.DerivedChannelMasks_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_DerivedChannelMasks(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.DerivedChannelMasks_empty(self)

    def size(self):
        return _mscl.DerivedChannelMasks_size(self)

    def clear(self):
        return _mscl.DerivedChannelMasks_clear(self)

    def swap(self, v):
        return _mscl.DerivedChannelMasks_swap(self, v)

    def get_allocator(self):
        return _mscl.DerivedChannelMasks_get_allocator(self)

    def begin(self):
        return _mscl.DerivedChannelMasks_begin(self)

    def end(self):
        return _mscl.DerivedChannelMasks_end(self)

    def rbegin(self):
        return _mscl.DerivedChannelMasks_rbegin(self)

    def rend(self):
        return _mscl.DerivedChannelMasks_rend(self)

    def count(self, x):
        return _mscl.DerivedChannelMasks_count(self, x)

    def erase(self, *args):
        return _mscl.DerivedChannelMasks_erase(self, *args)

    def find(self, x):
        return _mscl.DerivedChannelMasks_find(self, x)

    def lower_bound(self, x):
        return _mscl.DerivedChannelMasks_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.DerivedChannelMasks_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_DerivedChannelMasks
    __del__ = lambda self: None
DerivedChannelMasks_swigregister = _mscl.DerivedChannelMasks_swigregister
DerivedChannelMasks_swigregister(DerivedChannelMasks)

class SampleRates(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.SampleRates_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.SampleRates___nonzero__(self)

    def __bool__(self):
        return _mscl.SampleRates___bool__(self)

    def __len__(self):
        return _mscl.SampleRates___len__(self)

    def pop(self):
        return _mscl.SampleRates_pop(self)

    def __getslice__(self, i, j):
        return _mscl.SampleRates___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.SampleRates___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.SampleRates___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.SampleRates___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.SampleRates___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.SampleRates___setitem__(self, *args)

    def append(self, x):
        return _mscl.SampleRates_append(self, x)

    def empty(self):
        return _mscl.SampleRates_empty(self)

    def size(self):
        return _mscl.SampleRates_size(self)

    def clear(self):
        return _mscl.SampleRates_clear(self)

    def swap(self, v):
        return _mscl.SampleRates_swap(self, v)

    def get_allocator(self):
        return _mscl.SampleRates_get_allocator(self)

    def begin(self):
        return _mscl.SampleRates_begin(self)

    def end(self):
        return _mscl.SampleRates_end(self)

    def rbegin(self):
        return _mscl.SampleRates_rbegin(self)

    def rend(self):
        return _mscl.SampleRates_rend(self)

    def pop_back(self):
        return _mscl.SampleRates_pop_back(self)

    def erase(self, *args):
        return _mscl.SampleRates_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_SampleRates(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.SampleRates_push_back(self, x)

    def front(self):
        return _mscl.SampleRates_front(self)

    def back(self):
        return _mscl.SampleRates_back(self)

    def assign(self, n, x):
        return _mscl.SampleRates_assign(self, n, x)

    def resize(self, *args):
        return _mscl.SampleRates_resize(self, *args)

    def insert(self, *args):
        return _mscl.SampleRates_insert(self, *args)

    def reserve(self, n):
        return _mscl.SampleRates_reserve(self, n)

    def capacity(self):
        return _mscl.SampleRates_capacity(self)
    __swig_destroy__ = _mscl.delete_SampleRates
    __del__ = lambda self: None
SampleRates_swigregister = _mscl.SampleRates_swigregister
SampleRates_swigregister(SampleRates)

class ConfigIssues(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.ConfigIssues_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.ConfigIssues___nonzero__(self)

    def __bool__(self):
        return _mscl.ConfigIssues___bool__(self)

    def __len__(self):
        return _mscl.ConfigIssues___len__(self)

    def pop(self):
        return _mscl.ConfigIssues_pop(self)

    def __getslice__(self, i, j):
        return _mscl.ConfigIssues___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.ConfigIssues___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.ConfigIssues___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.ConfigIssues___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.ConfigIssues___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.ConfigIssues___setitem__(self, *args)

    def append(self, x):
        return _mscl.ConfigIssues_append(self, x)

    def empty(self):
        return _mscl.ConfigIssues_empty(self)

    def size(self):
        return _mscl.ConfigIssues_size(self)

    def clear(self):
        return _mscl.ConfigIssues_clear(self)

    def swap(self, v):
        return _mscl.ConfigIssues_swap(self, v)

    def get_allocator(self):
        return _mscl.ConfigIssues_get_allocator(self)

    def begin(self):
        return _mscl.ConfigIssues_begin(self)

    def end(self):
        return _mscl.ConfigIssues_end(self)

    def rbegin(self):
        return _mscl.ConfigIssues_rbegin(self)

    def rend(self):
        return _mscl.ConfigIssues_rend(self)

    def pop_back(self):
        return _mscl.ConfigIssues_pop_back(self)

    def erase(self, *args):
        return _mscl.ConfigIssues_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_ConfigIssues(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.ConfigIssues_push_back(self, x)

    def front(self):
        return _mscl.ConfigIssues_front(self)

    def back(self):
        return _mscl.ConfigIssues_back(self)

    def assign(self, n, x):
        return _mscl.ConfigIssues_assign(self, n, x)

    def resize(self, *args):
        return _mscl.ConfigIssues_resize(self, *args)

    def insert(self, *args):
        return _mscl.ConfigIssues_insert(self, *args)

    def reserve(self, n):
        return _mscl.ConfigIssues_reserve(self, n)

    def capacity(self):
        return _mscl.ConfigIssues_capacity(self)
    __swig_destroy__ = _mscl.delete_ConfigIssues
    __del__ = lambda self: None
ConfigIssues_swigregister = _mscl.ConfigIssues_swigregister
ConfigIssues_swigregister(ConfigIssues)

class MipChannelFields(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.MipChannelFields_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.MipChannelFields___nonzero__(self)

    def __bool__(self):
        return _mscl.MipChannelFields___bool__(self)

    def __len__(self):
        return _mscl.MipChannelFields___len__(self)

    def pop(self):
        return _mscl.MipChannelFields_pop(self)

    def __getslice__(self, i, j):
        return _mscl.MipChannelFields___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.MipChannelFields___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.MipChannelFields___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.MipChannelFields___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.MipChannelFields___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.MipChannelFields___setitem__(self, *args)

    def append(self, x):
        return _mscl.MipChannelFields_append(self, x)

    def empty(self):
        return _mscl.MipChannelFields_empty(self)

    def size(self):
        return _mscl.MipChannelFields_size(self)

    def clear(self):
        return _mscl.MipChannelFields_clear(self)

    def swap(self, v):
        return _mscl.MipChannelFields_swap(self, v)

    def get_allocator(self):
        return _mscl.MipChannelFields_get_allocator(self)

    def begin(self):
        return _mscl.MipChannelFields_begin(self)

    def end(self):
        return _mscl.MipChannelFields_end(self)

    def rbegin(self):
        return _mscl.MipChannelFields_rbegin(self)

    def rend(self):
        return _mscl.MipChannelFields_rend(self)

    def pop_back(self):
        return _mscl.MipChannelFields_pop_back(self)

    def erase(self, *args):
        return _mscl.MipChannelFields_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_MipChannelFields(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.MipChannelFields_push_back(self, x)

    def front(self):
        return _mscl.MipChannelFields_front(self)

    def back(self):
        return _mscl.MipChannelFields_back(self)

    def assign(self, n, x):
        return _mscl.MipChannelFields_assign(self, n, x)

    def resize(self, *args):
        return _mscl.MipChannelFields_resize(self, *args)

    def insert(self, *args):
        return _mscl.MipChannelFields_insert(self, *args)

    def reserve(self, n):
        return _mscl.MipChannelFields_reserve(self, n)

    def capacity(self):
        return _mscl.MipChannelFields_capacity(self)
    __swig_destroy__ = _mscl.delete_MipChannelFields
    __del__ = lambda self: None
MipChannelFields_swigregister = _mscl.MipChannelFields_swigregister
MipChannelFields_swigregister(MipChannelFields)

class MipCommands(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.MipCommands_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.MipCommands___nonzero__(self)

    def __bool__(self):
        return _mscl.MipCommands___bool__(self)

    def __len__(self):
        return _mscl.MipCommands___len__(self)

    def pop(self):
        return _mscl.MipCommands_pop(self)

    def __getslice__(self, i, j):
        return _mscl.MipCommands___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.MipCommands___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.MipCommands___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.MipCommands___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.MipCommands___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.MipCommands___setitem__(self, *args)

    def append(self, x):
        return _mscl.MipCommands_append(self, x)

    def empty(self):
        return _mscl.MipCommands_empty(self)

    def size(self):
        return _mscl.MipCommands_size(self)

    def clear(self):
        return _mscl.MipCommands_clear(self)

    def swap(self, v):
        return _mscl.MipCommands_swap(self, v)

    def get_allocator(self):
        return _mscl.MipCommands_get_allocator(self)

    def begin(self):
        return _mscl.MipCommands_begin(self)

    def end(self):
        return _mscl.MipCommands_end(self)

    def rbegin(self):
        return _mscl.MipCommands_rbegin(self)

    def rend(self):
        return _mscl.MipCommands_rend(self)

    def pop_back(self):
        return _mscl.MipCommands_pop_back(self)

    def erase(self, *args):
        return _mscl.MipCommands_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_MipCommands(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.MipCommands_push_back(self, x)

    def front(self):
        return _mscl.MipCommands_front(self)

    def back(self):
        return _mscl.MipCommands_back(self)

    def assign(self, n, x):
        return _mscl.MipCommands_assign(self, n, x)

    def resize(self, *args):
        return _mscl.MipCommands_resize(self, *args)

    def insert(self, *args):
        return _mscl.MipCommands_insert(self, *args)

    def reserve(self, n):
        return _mscl.MipCommands_reserve(self, n)

    def capacity(self):
        return _mscl.MipCommands_capacity(self)
    __swig_destroy__ = _mscl.delete_MipCommands
    __del__ = lambda self: None
MipCommands_swigregister = _mscl.MipCommands_swigregister
MipCommands_swigregister(MipCommands)

class ChannelGroups(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.ChannelGroups_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.ChannelGroups___nonzero__(self)

    def __bool__(self):
        return _mscl.ChannelGroups___bool__(self)

    def __len__(self):
        return _mscl.ChannelGroups___len__(self)

    def pop(self):
        return _mscl.ChannelGroups_pop(self)

    def __getslice__(self, i, j):
        return _mscl.ChannelGroups___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.ChannelGroups___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.ChannelGroups___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.ChannelGroups___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.ChannelGroups___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.ChannelGroups___setitem__(self, *args)

    def append(self, x):
        return _mscl.ChannelGroups_append(self, x)

    def empty(self):
        return _mscl.ChannelGroups_empty(self)

    def size(self):
        return _mscl.ChannelGroups_size(self)

    def clear(self):
        return _mscl.ChannelGroups_clear(self)

    def swap(self, v):
        return _mscl.ChannelGroups_swap(self, v)

    def get_allocator(self):
        return _mscl.ChannelGroups_get_allocator(self)

    def begin(self):
        return _mscl.ChannelGroups_begin(self)

    def end(self):
        return _mscl.ChannelGroups_end(self)

    def rbegin(self):
        return _mscl.ChannelGroups_rbegin(self)

    def rend(self):
        return _mscl.ChannelGroups_rend(self)

    def pop_back(self):
        return _mscl.ChannelGroups_pop_back(self)

    def erase(self, *args):
        return _mscl.ChannelGroups_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_ChannelGroups(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.ChannelGroups_push_back(self, x)

    def front(self):
        return _mscl.ChannelGroups_front(self)

    def back(self):
        return _mscl.ChannelGroups_back(self)

    def assign(self, n, x):
        return _mscl.ChannelGroups_assign(self, n, x)

    def resize(self, *args):
        return _mscl.ChannelGroups_resize(self, *args)

    def insert(self, *args):
        return _mscl.ChannelGroups_insert(self, *args)

    def reserve(self, n):
        return _mscl.ChannelGroups_reserve(self, n)

    def capacity(self):
        return _mscl.ChannelGroups_capacity(self)
    __swig_destroy__ = _mscl.delete_ChannelGroups
    __del__ = lambda self: None
ChannelGroups_swigregister = _mscl.ChannelGroups_swigregister
ChannelGroups_swigregister(ChannelGroups)

class WirelessChannels(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.WirelessChannels_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.WirelessChannels___nonzero__(self)

    def __bool__(self):
        return _mscl.WirelessChannels___bool__(self)

    def __len__(self):
        return _mscl.WirelessChannels___len__(self)

    def pop(self):
        return _mscl.WirelessChannels_pop(self)

    def __getslice__(self, i, j):
        return _mscl.WirelessChannels___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.WirelessChannels___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.WirelessChannels___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.WirelessChannels___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.WirelessChannels___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.WirelessChannels___setitem__(self, *args)

    def append(self, x):
        return _mscl.WirelessChannels_append(self, x)

    def empty(self):
        return _mscl.WirelessChannels_empty(self)

    def size(self):
        return _mscl.WirelessChannels_size(self)

    def clear(self):
        return _mscl.WirelessChannels_clear(self)

    def swap(self, v):
        return _mscl.WirelessChannels_swap(self, v)

    def get_allocator(self):
        return _mscl.WirelessChannels_get_allocator(self)

    def begin(self):
        return _mscl.WirelessChannels_begin(self)

    def end(self):
        return _mscl.WirelessChannels_end(self)

    def rbegin(self):
        return _mscl.WirelessChannels_rbegin(self)

    def rend(self):
        return _mscl.WirelessChannels_rend(self)

    def pop_back(self):
        return _mscl.WirelessChannels_pop_back(self)

    def erase(self, *args):
        return _mscl.WirelessChannels_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_WirelessChannels(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.WirelessChannels_push_back(self, x)

    def front(self):
        return _mscl.WirelessChannels_front(self)

    def back(self):
        return _mscl.WirelessChannels_back(self)

    def assign(self, n, x):
        return _mscl.WirelessChannels_assign(self, n, x)

    def resize(self, *args):
        return _mscl.WirelessChannels_resize(self, *args)

    def insert(self, *args):
        return _mscl.WirelessChannels_insert(self, *args)

    def reserve(self, n):
        return _mscl.WirelessChannels_reserve(self, n)

    def capacity(self):
        return _mscl.WirelessChannels_capacity(self)
    __swig_destroy__ = _mscl.delete_WirelessChannels
    __del__ = lambda self: None
WirelessChannels_swigregister = _mscl.WirelessChannels_swigregister
WirelessChannels_swigregister(WirelessChannels)

class DamageAngles(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.DamageAngles_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.DamageAngles___nonzero__(self)

    def __bool__(self):
        return _mscl.DamageAngles___bool__(self)

    def __len__(self):
        return _mscl.DamageAngles___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 _mscl.DamageAngles___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.DamageAngles___delitem__(self, key)

    def has_key(self, key):
        return _mscl.DamageAngles_has_key(self, key)

    def keys(self):
        return _mscl.DamageAngles_keys(self)

    def values(self):
        return _mscl.DamageAngles_values(self)

    def items(self):
        return _mscl.DamageAngles_items(self)

    def __contains__(self, key):
        return _mscl.DamageAngles___contains__(self, key)

    def key_iterator(self):
        return _mscl.DamageAngles_key_iterator(self)

    def value_iterator(self):
        return _mscl.DamageAngles_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.DamageAngles___setitem__(self, *args)

    def asdict(self):
        return _mscl.DamageAngles_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_DamageAngles(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.DamageAngles_empty(self)

    def size(self):
        return _mscl.DamageAngles_size(self)

    def clear(self):
        return _mscl.DamageAngles_clear(self)

    def swap(self, v):
        return _mscl.DamageAngles_swap(self, v)

    def get_allocator(self):
        return _mscl.DamageAngles_get_allocator(self)

    def begin(self):
        return _mscl.DamageAngles_begin(self)

    def end(self):
        return _mscl.DamageAngles_end(self)

    def rbegin(self):
        return _mscl.DamageAngles_rbegin(self)

    def rend(self):
        return _mscl.DamageAngles_rend(self)

    def count(self, x):
        return _mscl.DamageAngles_count(self, x)

    def erase(self, *args):
        return _mscl.DamageAngles_erase(self, *args)

    def find(self, x):
        return _mscl.DamageAngles_find(self, x)

    def lower_bound(self, x):
        return _mscl.DamageAngles_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.DamageAngles_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_DamageAngles
    __del__ = lambda self: None
DamageAngles_swigregister = _mscl.DamageAngles_swigregister
DamageAngles_swigregister(DamageAngles)

class SnCurveSegments(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.SnCurveSegments_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.SnCurveSegments___nonzero__(self)

    def __bool__(self):
        return _mscl.SnCurveSegments___bool__(self)

    def __len__(self):
        return _mscl.SnCurveSegments___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 _mscl.SnCurveSegments___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.SnCurveSegments___delitem__(self, key)

    def has_key(self, key):
        return _mscl.SnCurveSegments_has_key(self, key)

    def keys(self):
        return _mscl.SnCurveSegments_keys(self)

    def values(self):
        return _mscl.SnCurveSegments_values(self)

    def items(self):
        return _mscl.SnCurveSegments_items(self)

    def __contains__(self, key):
        return _mscl.SnCurveSegments___contains__(self, key)

    def key_iterator(self):
        return _mscl.SnCurveSegments_key_iterator(self)

    def value_iterator(self):
        return _mscl.SnCurveSegments_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.SnCurveSegments___setitem__(self, *args)

    def asdict(self):
        return _mscl.SnCurveSegments_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_SnCurveSegments(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.SnCurveSegments_empty(self)

    def size(self):
        return _mscl.SnCurveSegments_size(self)

    def clear(self):
        return _mscl.SnCurveSegments_clear(self)

    def swap(self, v):
        return _mscl.SnCurveSegments_swap(self, v)

    def get_allocator(self):
        return _mscl.SnCurveSegments_get_allocator(self)

    def begin(self):
        return _mscl.SnCurveSegments_begin(self)

    def end(self):
        return _mscl.SnCurveSegments_end(self)

    def rbegin(self):
        return _mscl.SnCurveSegments_rbegin(self)

    def rend(self):
        return _mscl.SnCurveSegments_rend(self)

    def count(self, x):
        return _mscl.SnCurveSegments_count(self, x)

    def erase(self, *args):
        return _mscl.SnCurveSegments_erase(self, *args)

    def find(self, x):
        return _mscl.SnCurveSegments_find(self, x)

    def lower_bound(self, x):
        return _mscl.SnCurveSegments_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.SnCurveSegments_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_SnCurveSegments
    __del__ = lambda self: None
SnCurveSegments_swigregister = _mscl.SnCurveSegments_swigregister
SnCurveSegments_swigregister(SnCurveSegments)

class RfSweep(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.RfSweep_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.RfSweep___nonzero__(self)

    def __bool__(self):
        return _mscl.RfSweep___bool__(self)

    def __len__(self):
        return _mscl.RfSweep___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 _mscl.RfSweep___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.RfSweep___delitem__(self, key)

    def has_key(self, key):
        return _mscl.RfSweep_has_key(self, key)

    def keys(self):
        return _mscl.RfSweep_keys(self)

    def values(self):
        return _mscl.RfSweep_values(self)

    def items(self):
        return _mscl.RfSweep_items(self)

    def __contains__(self, key):
        return _mscl.RfSweep___contains__(self, key)

    def key_iterator(self):
        return _mscl.RfSweep_key_iterator(self)

    def value_iterator(self):
        return _mscl.RfSweep_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.RfSweep___setitem__(self, *args)

    def asdict(self):
        return _mscl.RfSweep_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_RfSweep(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.RfSweep_empty(self)

    def size(self):
        return _mscl.RfSweep_size(self)

    def clear(self):
        return _mscl.RfSweep_clear(self)

    def swap(self, v):
        return _mscl.RfSweep_swap(self, v)

    def get_allocator(self):
        return _mscl.RfSweep_get_allocator(self)

    def begin(self):
        return _mscl.RfSweep_begin(self)

    def end(self):
        return _mscl.RfSweep_end(self)

    def rbegin(self):
        return _mscl.RfSweep_rbegin(self)

    def rend(self):
        return _mscl.RfSweep_rend(self)

    def count(self, x):
        return _mscl.RfSweep_count(self, x)

    def erase(self, *args):
        return _mscl.RfSweep_erase(self, *args)

    def find(self, x):
        return _mscl.RfSweep_find(self, x)

    def lower_bound(self, x):
        return _mscl.RfSweep_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.RfSweep_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_RfSweep
    __del__ = lambda self: None
RfSweep_swigregister = _mscl.RfSweep_swigregister
RfSweep_swigregister(RfSweep)

class Triggers(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.Triggers_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.Triggers___nonzero__(self)

    def __bool__(self):
        return _mscl.Triggers___bool__(self)

    def __len__(self):
        return _mscl.Triggers___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 _mscl.Triggers___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.Triggers___delitem__(self, key)

    def has_key(self, key):
        return _mscl.Triggers_has_key(self, key)

    def keys(self):
        return _mscl.Triggers_keys(self)

    def values(self):
        return _mscl.Triggers_values(self)

    def items(self):
        return _mscl.Triggers_items(self)

    def __contains__(self, key):
        return _mscl.Triggers___contains__(self, key)

    def key_iterator(self):
        return _mscl.Triggers_key_iterator(self)

    def value_iterator(self):
        return _mscl.Triggers_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.Triggers___setitem__(self, *args)

    def asdict(self):
        return _mscl.Triggers_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_Triggers(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.Triggers_empty(self)

    def size(self):
        return _mscl.Triggers_size(self)

    def clear(self):
        return _mscl.Triggers_clear(self)

    def swap(self, v):
        return _mscl.Triggers_swap(self, v)

    def get_allocator(self):
        return _mscl.Triggers_get_allocator(self)

    def begin(self):
        return _mscl.Triggers_begin(self)

    def end(self):
        return _mscl.Triggers_end(self)

    def rbegin(self):
        return _mscl.Triggers_rbegin(self)

    def rend(self):
        return _mscl.Triggers_rend(self)

    def count(self, x):
        return _mscl.Triggers_count(self, x)

    def erase(self, *args):
        return _mscl.Triggers_erase(self, *args)

    def find(self, x):
        return _mscl.Triggers_find(self, x)

    def lower_bound(self, x):
        return _mscl.Triggers_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.Triggers_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_Triggers
    __del__ = lambda self: None
Triggers_swigregister = _mscl.Triggers_swigregister
Triggers_swigregister(Triggers)

class ChannelCalMap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.ChannelCalMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.ChannelCalMap___nonzero__(self)

    def __bool__(self):
        return _mscl.ChannelCalMap___bool__(self)

    def __len__(self):
        return _mscl.ChannelCalMap___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 _mscl.ChannelCalMap___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.ChannelCalMap___delitem__(self, key)

    def has_key(self, key):
        return _mscl.ChannelCalMap_has_key(self, key)

    def keys(self):
        return _mscl.ChannelCalMap_keys(self)

    def values(self):
        return _mscl.ChannelCalMap_values(self)

    def items(self):
        return _mscl.ChannelCalMap_items(self)

    def __contains__(self, key):
        return _mscl.ChannelCalMap___contains__(self, key)

    def key_iterator(self):
        return _mscl.ChannelCalMap_key_iterator(self)

    def value_iterator(self):
        return _mscl.ChannelCalMap_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.ChannelCalMap___setitem__(self, *args)

    def asdict(self):
        return _mscl.ChannelCalMap_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_ChannelCalMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.ChannelCalMap_empty(self)

    def size(self):
        return _mscl.ChannelCalMap_size(self)

    def clear(self):
        return _mscl.ChannelCalMap_clear(self)

    def swap(self, v):
        return _mscl.ChannelCalMap_swap(self, v)

    def get_allocator(self):
        return _mscl.ChannelCalMap_get_allocator(self)

    def begin(self):
        return _mscl.ChannelCalMap_begin(self)

    def end(self):
        return _mscl.ChannelCalMap_end(self)

    def rbegin(self):
        return _mscl.ChannelCalMap_rbegin(self)

    def rend(self):
        return _mscl.ChannelCalMap_rend(self)

    def count(self, x):
        return _mscl.ChannelCalMap_count(self, x)

    def erase(self, *args):
        return _mscl.ChannelCalMap_erase(self, *args)

    def find(self, x):
        return _mscl.ChannelCalMap_find(self, x)

    def lower_bound(self, x):
        return _mscl.ChannelCalMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.ChannelCalMap_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_ChannelCalMap
    __del__ = lambda self: None
ChannelCalMap_swigregister = _mscl.ChannelCalMap_swigregister
ChannelCalMap_swigregister(ChannelCalMap)

class ConnectionDebugDataVec(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.ConnectionDebugDataVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.ConnectionDebugDataVec___nonzero__(self)

    def __bool__(self):
        return _mscl.ConnectionDebugDataVec___bool__(self)

    def __len__(self):
        return _mscl.ConnectionDebugDataVec___len__(self)

    def pop(self):
        return _mscl.ConnectionDebugDataVec_pop(self)

    def __getslice__(self, i, j):
        return _mscl.ConnectionDebugDataVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.ConnectionDebugDataVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.ConnectionDebugDataVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.ConnectionDebugDataVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.ConnectionDebugDataVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.ConnectionDebugDataVec___setitem__(self, *args)

    def append(self, x):
        return _mscl.ConnectionDebugDataVec_append(self, x)

    def empty(self):
        return _mscl.ConnectionDebugDataVec_empty(self)

    def size(self):
        return _mscl.ConnectionDebugDataVec_size(self)

    def clear(self):
        return _mscl.ConnectionDebugDataVec_clear(self)

    def swap(self, v):
        return _mscl.ConnectionDebugDataVec_swap(self, v)

    def get_allocator(self):
        return _mscl.ConnectionDebugDataVec_get_allocator(self)

    def begin(self):
        return _mscl.ConnectionDebugDataVec_begin(self)

    def end(self):
        return _mscl.ConnectionDebugDataVec_end(self)

    def rbegin(self):
        return _mscl.ConnectionDebugDataVec_rbegin(self)

    def rend(self):
        return _mscl.ConnectionDebugDataVec_rend(self)

    def pop_back(self):
        return _mscl.ConnectionDebugDataVec_pop_back(self)

    def erase(self, *args):
        return _mscl.ConnectionDebugDataVec_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_ConnectionDebugDataVec(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.ConnectionDebugDataVec_push_back(self, x)

    def front(self):
        return _mscl.ConnectionDebugDataVec_front(self)

    def back(self):
        return _mscl.ConnectionDebugDataVec_back(self)

    def assign(self, n, x):
        return _mscl.ConnectionDebugDataVec_assign(self, n, x)

    def resize(self, *args):
        return _mscl.ConnectionDebugDataVec_resize(self, *args)

    def insert(self, *args):
        return _mscl.ConnectionDebugDataVec_insert(self, *args)

    def reserve(self, n):
        return _mscl.ConnectionDebugDataVec_reserve(self, n)

    def capacity(self):
        return _mscl.ConnectionDebugDataVec_capacity(self)
    __swig_destroy__ = _mscl.delete_ConnectionDebugDataVec
    __del__ = lambda self: None
ConnectionDebugDataVec_swigregister = _mscl.ConnectionDebugDataVec_swigregister
ConnectionDebugDataVec_swigregister(ConnectionDebugDataVec)

class SatellitePRNs(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.SatellitePRNs_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.SatellitePRNs___nonzero__(self)

    def __bool__(self):
        return _mscl.SatellitePRNs___bool__(self)

    def __len__(self):
        return _mscl.SatellitePRNs___len__(self)

    def pop(self):
        return _mscl.SatellitePRNs_pop(self)

    def __getslice__(self, i, j):
        return _mscl.SatellitePRNs___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.SatellitePRNs___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.SatellitePRNs___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.SatellitePRNs___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.SatellitePRNs___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.SatellitePRNs___setitem__(self, *args)

    def append(self, x):
        return _mscl.SatellitePRNs_append(self, x)

    def empty(self):
        return _mscl.SatellitePRNs_empty(self)

    def size(self):
        return _mscl.SatellitePRNs_size(self)

    def clear(self):
        return _mscl.SatellitePRNs_clear(self)

    def swap(self, v):
        return _mscl.SatellitePRNs_swap(self, v)

    def get_allocator(self):
        return _mscl.SatellitePRNs_get_allocator(self)

    def begin(self):
        return _mscl.SatellitePRNs_begin(self)

    def end(self):
        return _mscl.SatellitePRNs_end(self)

    def rbegin(self):
        return _mscl.SatellitePRNs_rbegin(self)

    def rend(self):
        return _mscl.SatellitePRNs_rend(self)

    def pop_back(self):
        return _mscl.SatellitePRNs_pop_back(self)

    def erase(self, *args):
        return _mscl.SatellitePRNs_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_SatellitePRNs(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.SatellitePRNs_push_back(self, x)

    def front(self):
        return _mscl.SatellitePRNs_front(self)

    def back(self):
        return _mscl.SatellitePRNs_back(self)

    def assign(self, n, x):
        return _mscl.SatellitePRNs_assign(self, n, x)

    def resize(self, *args):
        return _mscl.SatellitePRNs_resize(self, *args)

    def insert(self, *args):
        return _mscl.SatellitePRNs_insert(self, *args)

    def reserve(self, n):
        return _mscl.SatellitePRNs_reserve(self, n)

    def capacity(self):
        return _mscl.SatellitePRNs_capacity(self)
    __swig_destroy__ = _mscl.delete_SatellitePRNs
    __del__ = lambda self: None
SatellitePRNs_swigregister = _mscl.SatellitePRNs_swigregister
SatellitePRNs_swigregister(SatellitePRNs)

class Constellations(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.Constellations_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.Constellations___nonzero__(self)

    def __bool__(self):
        return _mscl.Constellations___bool__(self)

    def __len__(self):
        return _mscl.Constellations___len__(self)

    def pop(self):
        return _mscl.Constellations_pop(self)

    def __getslice__(self, i, j):
        return _mscl.Constellations___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.Constellations___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.Constellations___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.Constellations___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.Constellations___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.Constellations___setitem__(self, *args)

    def append(self, x):
        return _mscl.Constellations_append(self, x)

    def empty(self):
        return _mscl.Constellations_empty(self)

    def size(self):
        return _mscl.Constellations_size(self)

    def clear(self):
        return _mscl.Constellations_clear(self)

    def swap(self, v):
        return _mscl.Constellations_swap(self, v)

    def get_allocator(self):
        return _mscl.Constellations_get_allocator(self)

    def begin(self):
        return _mscl.Constellations_begin(self)

    def end(self):
        return _mscl.Constellations_end(self)

    def rbegin(self):
        return _mscl.Constellations_rbegin(self)

    def rend(self):
        return _mscl.Constellations_rend(self)

    def pop_back(self):
        return _mscl.Constellations_pop_back(self)

    def erase(self, *args):
        return _mscl.Constellations_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_Constellations(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.Constellations_push_back(self, x)

    def front(self):
        return _mscl.Constellations_front(self)

    def back(self):
        return _mscl.Constellations_back(self)

    def assign(self, n, x):
        return _mscl.Constellations_assign(self, n, x)

    def resize(self, *args):
        return _mscl.Constellations_resize(self, *args)

    def insert(self, *args):
        return _mscl.Constellations_insert(self, *args)

    def reserve(self, n):
        return _mscl.Constellations_reserve(self, n)

    def capacity(self):
        return _mscl.Constellations_capacity(self)
    __swig_destroy__ = _mscl.delete_Constellations
    __del__ = lambda self: None
Constellations_swigregister = _mscl.Constellations_swigregister
Constellations_swigregister(Constellations)

class HeadingUpdateOptionsList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.HeadingUpdateOptionsList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.HeadingUpdateOptionsList___nonzero__(self)

    def __bool__(self):
        return _mscl.HeadingUpdateOptionsList___bool__(self)

    def __len__(self):
        return _mscl.HeadingUpdateOptionsList___len__(self)

    def pop(self):
        return _mscl.HeadingUpdateOptionsList_pop(self)

    def __getslice__(self, i, j):
        return _mscl.HeadingUpdateOptionsList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.HeadingUpdateOptionsList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.HeadingUpdateOptionsList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.HeadingUpdateOptionsList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.HeadingUpdateOptionsList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.HeadingUpdateOptionsList___setitem__(self, *args)

    def append(self, x):
        return _mscl.HeadingUpdateOptionsList_append(self, x)

    def empty(self):
        return _mscl.HeadingUpdateOptionsList_empty(self)

    def size(self):
        return _mscl.HeadingUpdateOptionsList_size(self)

    def clear(self):
        return _mscl.HeadingUpdateOptionsList_clear(self)

    def swap(self, v):
        return _mscl.HeadingUpdateOptionsList_swap(self, v)

    def get_allocator(self):
        return _mscl.HeadingUpdateOptionsList_get_allocator(self)

    def begin(self):
        return _mscl.HeadingUpdateOptionsList_begin(self)

    def end(self):
        return _mscl.HeadingUpdateOptionsList_end(self)

    def rbegin(self):
        return _mscl.HeadingUpdateOptionsList_rbegin(self)

    def rend(self):
        return _mscl.HeadingUpdateOptionsList_rend(self)

    def pop_back(self):
        return _mscl.HeadingUpdateOptionsList_pop_back(self)

    def erase(self, *args):
        return _mscl.HeadingUpdateOptionsList_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_HeadingUpdateOptionsList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.HeadingUpdateOptionsList_push_back(self, x)

    def front(self):
        return _mscl.HeadingUpdateOptionsList_front(self)

    def back(self):
        return _mscl.HeadingUpdateOptionsList_back(self)

    def assign(self, n, x):
        return _mscl.HeadingUpdateOptionsList_assign(self, n, x)

    def resize(self, *args):
        return _mscl.HeadingUpdateOptionsList_resize(self, *args)

    def insert(self, *args):
        return _mscl.HeadingUpdateOptionsList_insert(self, *args)

    def reserve(self, n):
        return _mscl.HeadingUpdateOptionsList_reserve(self, n)

    def capacity(self):
        return _mscl.HeadingUpdateOptionsList_capacity(self)
    __swig_destroy__ = _mscl.delete_HeadingUpdateOptionsList
    __del__ = lambda self: None
HeadingUpdateOptionsList_swigregister = _mscl.HeadingUpdateOptionsList_swigregister
HeadingUpdateOptionsList_swigregister(HeadingUpdateOptionsList)

class AdaptiveMeasurementModes(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.AdaptiveMeasurementModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.AdaptiveMeasurementModes___nonzero__(self)

    def __bool__(self):
        return _mscl.AdaptiveMeasurementModes___bool__(self)

    def __len__(self):
        return _mscl.AdaptiveMeasurementModes___len__(self)

    def pop(self):
        return _mscl.AdaptiveMeasurementModes_pop(self)

    def __getslice__(self, i, j):
        return _mscl.AdaptiveMeasurementModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.AdaptiveMeasurementModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.AdaptiveMeasurementModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.AdaptiveMeasurementModes___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.AdaptiveMeasurementModes___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.AdaptiveMeasurementModes___setitem__(self, *args)

    def append(self, x):
        return _mscl.AdaptiveMeasurementModes_append(self, x)

    def empty(self):
        return _mscl.AdaptiveMeasurementModes_empty(self)

    def size(self):
        return _mscl.AdaptiveMeasurementModes_size(self)

    def clear(self):
        return _mscl.AdaptiveMeasurementModes_clear(self)

    def swap(self, v):
        return _mscl.AdaptiveMeasurementModes_swap(self, v)

    def get_allocator(self):
        return _mscl.AdaptiveMeasurementModes_get_allocator(self)

    def begin(self):
        return _mscl.AdaptiveMeasurementModes_begin(self)

    def end(self):
        return _mscl.AdaptiveMeasurementModes_end(self)

    def rbegin(self):
        return _mscl.AdaptiveMeasurementModes_rbegin(self)

    def rend(self):
        return _mscl.AdaptiveMeasurementModes_rend(self)

    def pop_back(self):
        return _mscl.AdaptiveMeasurementModes_pop_back(self)

    def erase(self, *args):
        return _mscl.AdaptiveMeasurementModes_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_AdaptiveMeasurementModes(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.AdaptiveMeasurementModes_push_back(self, x)

    def front(self):
        return _mscl.AdaptiveMeasurementModes_front(self)

    def back(self):
        return _mscl.AdaptiveMeasurementModes_back(self)

    def assign(self, n, x):
        return _mscl.AdaptiveMeasurementModes_assign(self, n, x)

    def resize(self, *args):
        return _mscl.AdaptiveMeasurementModes_resize(self, *args)

    def insert(self, *args):
        return _mscl.AdaptiveMeasurementModes_insert(self, *args)

    def reserve(self, n):
        return _mscl.AdaptiveMeasurementModes_reserve(self, n)

    def capacity(self):
        return _mscl.AdaptiveMeasurementModes_capacity(self)
    __swig_destroy__ = _mscl.delete_AdaptiveMeasurementModes
    __del__ = lambda self: None
AdaptiveMeasurementModes_swigregister = _mscl.AdaptiveMeasurementModes_swigregister
AdaptiveMeasurementModes_swigregister(AdaptiveMeasurementModes)

class WsdaMap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.WsdaMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.WsdaMap___nonzero__(self)

    def __bool__(self):
        return _mscl.WsdaMap___bool__(self)

    def __len__(self):
        return _mscl.WsdaMap___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 _mscl.WsdaMap___getitem__(self, key)

    def __delitem__(self, key):
        return _mscl.WsdaMap___delitem__(self, key)

    def has_key(self, key):
        return _mscl.WsdaMap_has_key(self, key)

    def keys(self):
        return _mscl.WsdaMap_keys(self)

    def values(self):
        return _mscl.WsdaMap_values(self)

    def items(self):
        return _mscl.WsdaMap_items(self)

    def __contains__(self, key):
        return _mscl.WsdaMap___contains__(self, key)

    def key_iterator(self):
        return _mscl.WsdaMap_key_iterator(self)

    def value_iterator(self):
        return _mscl.WsdaMap_value_iterator(self)

    def __setitem__(self, *args):
        return _mscl.WsdaMap___setitem__(self, *args)

    def asdict(self):
        return _mscl.WsdaMap_asdict(self)

    def __init__(self, *args):
        this = _mscl.new_WsdaMap(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _mscl.WsdaMap_empty(self)

    def size(self):
        return _mscl.WsdaMap_size(self)

    def clear(self):
        return _mscl.WsdaMap_clear(self)

    def swap(self, v):
        return _mscl.WsdaMap_swap(self, v)

    def get_allocator(self):
        return _mscl.WsdaMap_get_allocator(self)

    def begin(self):
        return _mscl.WsdaMap_begin(self)

    def end(self):
        return _mscl.WsdaMap_end(self)

    def rbegin(self):
        return _mscl.WsdaMap_rbegin(self)

    def rend(self):
        return _mscl.WsdaMap_rend(self)

    def count(self, x):
        return _mscl.WsdaMap_count(self, x)

    def erase(self, *args):
        return _mscl.WsdaMap_erase(self, *args)

    def find(self, x):
        return _mscl.WsdaMap_find(self, x)

    def lower_bound(self, x):
        return _mscl.WsdaMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _mscl.WsdaMap_upper_bound(self, x)
    __swig_destroy__ = _mscl.delete_WsdaMap
    __del__ = lambda self: None
WsdaMap_swigregister = _mscl.WsdaMap_swigregister
WsdaMap_swigregister(WsdaMap)

class Bins(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        return _mscl.Bins_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _mscl.Bins___nonzero__(self)

    def __bool__(self):
        return _mscl.Bins___bool__(self)

    def __len__(self):
        return _mscl.Bins___len__(self)

    def pop(self):
        return _mscl.Bins_pop(self)

    def __getslice__(self, i, j):
        return _mscl.Bins___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _mscl.Bins___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _mscl.Bins___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _mscl.Bins___delitem__(self, *args)

    def __getitem__(self, *args):
        return _mscl.Bins___getitem__(self, *args)

    def __setitem__(self, *args):
        return _mscl.Bins___setitem__(self, *args)

    def append(self, x):
        return _mscl.Bins_append(self, x)

    def empty(self):
        return _mscl.Bins_empty(self)

    def size(self):
        return _mscl.Bins_size(self)

    def clear(self):
        return _mscl.Bins_clear(self)

    def swap(self, v):
        return _mscl.Bins_swap(self, v)

    def get_allocator(self):
        return _mscl.Bins_get_allocator(self)

    def begin(self):
        return _mscl.Bins_begin(self)

    def end(self):
        return _mscl.Bins_end(self)

    def rbegin(self):
        return _mscl.Bins_rbegin(self)

    def rend(self):
        return _mscl.Bins_rend(self)

    def pop_back(self):
        return _mscl.Bins_pop_back(self)

    def erase(self, *args):
        return _mscl.Bins_erase(self, *args)

    def __init__(self, *args):
        this = _mscl.new_Bins(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _mscl.Bins_push_back(self, x)

    def front(self):
        return _mscl.Bins_front(self)

    def back(self):
        return _mscl.Bins_back(self)

    def assign(self, n, x):
        return _mscl.Bins_assign(self, n, x)

    def insert(self, *args):
        return _mscl.Bins_insert(self, *args)

    def reserve(self, n):
        return _mscl.Bins_reserve(self, n)

    def capacity(self):
        return _mscl.Bins_capacity(self)
    __swig_destroy__ = _mscl.delete_Bins
    __del__ = lambda self: None
Bins_swigregister = _mscl.Bins_swigregister
Bins_swigregister(Bins)

class Error(Exception):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Error, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error
    __del__ = lambda self: None

    def what(self):
        return _mscl.Error_what(self)

    def __str__(self):
        return _mscl.Error___str__(self)
Error_swigregister = _mscl.Error_swigregister
Error_swigregister(Error)

class Error_NotSupported(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_NotSupported, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_NotSupported, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_NotSupported(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_NotSupported
    __del__ = lambda self: None
Error_NotSupported_swigregister = _mscl.Error_NotSupported_swigregister
Error_NotSupported_swigregister(Error_NotSupported)

class Error_NoData(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_NoData, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_NoData, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_NoData(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_NoData
    __del__ = lambda self: None
Error_NoData_swigregister = _mscl.Error_NoData_swigregister
Error_NoData_swigregister(Error_NoData)

class Error_BadDataType(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_BadDataType, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_BadDataType, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _mscl.new_Error_BadDataType()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_BadDataType
    __del__ = lambda self: None
Error_BadDataType_swigregister = _mscl.Error_BadDataType_swigregister
Error_BadDataType_swigregister(Error_BadDataType)

class Error_UnknownSampleRate(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_UnknownSampleRate, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_UnknownSampleRate, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_UnknownSampleRate(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_UnknownSampleRate
    __del__ = lambda self: None
Error_UnknownSampleRate_swigregister = _mscl.Error_UnknownSampleRate_swigregister
Error_UnknownSampleRate_swigregister(Error_UnknownSampleRate)

class Error_Communication(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_Communication, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_Communication, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_Communication(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_Communication
    __del__ = lambda self: None
Error_Communication_swigregister = _mscl.Error_Communication_swigregister
Error_Communication_swigregister(Error_Communication)

class Error_NodeCommunication(Error_Communication):
    __swig_setmethods__ = {}
    for _s in [Error_Communication]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_NodeCommunication, name, value)
    __swig_getmethods__ = {}
    for _s in [Error_Communication]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_NodeCommunication, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_NodeCommunication(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def nodeAddress(self):
        return _mscl.Error_NodeCommunication_nodeAddress(self)
    __swig_destroy__ = _mscl.delete_Error_NodeCommunication
    __del__ = lambda self: None
Error_NodeCommunication_swigregister = _mscl.Error_NodeCommunication_swigregister
Error_NodeCommunication_swigregister(Error_NodeCommunication)

class Error_Connection(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_Connection, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_Connection, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_Connection(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_Connection
    __del__ = lambda self: None

    def code(self):
        return _mscl.Error_Connection_code(self)

    def value(self):
        return _mscl.Error_Connection_value(self)
Error_Connection_swigregister = _mscl.Error_Connection_swigregister
Error_Connection_swigregister(Error_Connection)

class Error_InvalidSerialPort(Error_Connection):
    __swig_setmethods__ = {}
    for _s in [Error_Connection]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_InvalidSerialPort, name, value)
    __swig_getmethods__ = {}
    for _s in [Error_Connection]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_InvalidSerialPort, name)
    __repr__ = _swig_repr

    def __init__(self, code):
        this = _mscl.new_Error_InvalidSerialPort(code)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_InvalidSerialPort
    __del__ = lambda self: None
Error_InvalidSerialPort_swigregister = _mscl.Error_InvalidSerialPort_swigregister
Error_InvalidSerialPort_swigregister(Error_InvalidSerialPort)

class Error_InvalidTcpServer(Error_Connection):
    __swig_setmethods__ = {}
    for _s in [Error_Connection]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_InvalidTcpServer, name, value)
    __swig_getmethods__ = {}
    for _s in [Error_Connection]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_InvalidTcpServer, name)
    __repr__ = _swig_repr

    def __init__(self, code, message):
        this = _mscl.new_Error_InvalidTcpServer(code, message)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_InvalidTcpServer
    __del__ = lambda self: None
Error_InvalidTcpServer_swigregister = _mscl.Error_InvalidTcpServer_swigregister
Error_InvalidTcpServer_swigregister(Error_InvalidTcpServer)

class Error_InvalidUnixSocket(Error_Connection):
    __swig_setmethods__ = {}
    for _s in [Error_Connection]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_InvalidUnixSocket, name, value)
    __swig_getmethods__ = {}
    for _s in [Error_Connection]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_InvalidUnixSocket, name)
    __repr__ = _swig_repr

    def __init__(self, code, message):
        this = _mscl.new_Error_InvalidUnixSocket(code, message)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_InvalidUnixSocket
    __del__ = lambda self: None
Error_InvalidUnixSocket_swigregister = _mscl.Error_InvalidUnixSocket_swigregister
Error_InvalidUnixSocket_swigregister(Error_InvalidUnixSocket)

class Error_MipCmdFailed(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_MipCmdFailed, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_MipCmdFailed, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_MipCmdFailed(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_MipCmdFailed
    __del__ = lambda self: None

    def code(self):
        return _mscl.Error_MipCmdFailed_code(self)

    def value(self):
        return _mscl.Error_MipCmdFailed_value(self)
Error_MipCmdFailed_swigregister = _mscl.Error_MipCmdFailed_swigregister
Error_MipCmdFailed_swigregister(Error_MipCmdFailed)

class Error_InvalidConfig(Error):
    __swig_setmethods__ = {}
    for _s in [Error]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_InvalidConfig, name, value)
    __swig_getmethods__ = {}
    for _s in [Error]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_InvalidConfig, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _mscl.new_Error_InvalidConfig(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_InvalidConfig
    __del__ = lambda self: None

    def issues(self):
        return _mscl.Error_InvalidConfig_issues(self)
Error_InvalidConfig_swigregister = _mscl.Error_InvalidConfig_swigregister
Error_InvalidConfig_swigregister(Error_InvalidConfig)

class Error_InvalidNodeConfig(Error_InvalidConfig):
    __swig_setmethods__ = {}
    for _s in [Error_InvalidConfig]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error_InvalidNodeConfig, name, value)
    __swig_getmethods__ = {}
    for _s in [Error_InvalidConfig]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Error_InvalidNodeConfig, name)
    __repr__ = _swig_repr

    def __init__(self, issues, nodeAddress):
        this = _mscl.new_Error_InvalidNodeConfig(issues, nodeAddress)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _mscl.delete_Error_InvalidNodeConfig
    __del__ = lambda self: None

    def nodeAddress(self):
        return _mscl.Error_InvalidNodeConfig_nodeAddress(self)
Error_InvalidNodeConfig_swigregister = _mscl.Error_InvalidNodeConfig_swigregister
Error_InvalidNodeConfig_swigregister(Error_InvalidNodeConfig)



