Source code for controlAPI

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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _HC_API_PythonPackage
else:
    import _HC_API_PythonPackage

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


import weakref

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        return _HC_API_PythonPackage.FloatVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _HC_API_PythonPackage.FloatVector___nonzero__(self)

    def __bool__(self):
        return _HC_API_PythonPackage.FloatVector___bool__(self)

    def __len__(self):
        return _HC_API_PythonPackage.FloatVector___len__(self)

    def __getslice__(self, i, j):
        return _HC_API_PythonPackage.FloatVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _HC_API_PythonPackage.FloatVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _HC_API_PythonPackage.FloatVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _HC_API_PythonPackage.FloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _HC_API_PythonPackage.FloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _HC_API_PythonPackage.FloatVector___setitem__(self, *args)

    def pop(self):
        return _HC_API_PythonPackage.FloatVector_pop(self)

    def append(self, x):
        return _HC_API_PythonPackage.FloatVector_append(self, x)

    def empty(self):
        return _HC_API_PythonPackage.FloatVector_empty(self)

    def size(self):
        return _HC_API_PythonPackage.FloatVector_size(self)

    def swap(self, v):
        return _HC_API_PythonPackage.FloatVector_swap(self, v)

    def begin(self):
        return _HC_API_PythonPackage.FloatVector_begin(self)

    def end(self):
        return _HC_API_PythonPackage.FloatVector_end(self)

    def rbegin(self):
        return _HC_API_PythonPackage.FloatVector_rbegin(self)

    def rend(self):
        return _HC_API_PythonPackage.FloatVector_rend(self)

    def clear(self):
        return _HC_API_PythonPackage.FloatVector_clear(self)

    def get_allocator(self):
        return _HC_API_PythonPackage.FloatVector_get_allocator(self)

    def pop_back(self):
        return _HC_API_PythonPackage.FloatVector_pop_back(self)

    def erase(self, *args):
        return _HC_API_PythonPackage.FloatVector_erase(self, *args)

    def __init__(self, *args):
        _HC_API_PythonPackage.FloatVector_swiginit(self, _HC_API_PythonPackage.new_FloatVector(*args))

    def push_back(self, x):
        return _HC_API_PythonPackage.FloatVector_push_back(self, x)

    def front(self):
        return _HC_API_PythonPackage.FloatVector_front(self)

    def back(self):
        return _HC_API_PythonPackage.FloatVector_back(self)

    def assign(self, n, x):
        return _HC_API_PythonPackage.FloatVector_assign(self, n, x)

    def resize(self, *args):
        return _HC_API_PythonPackage.FloatVector_resize(self, *args)

    def insert(self, *args):
        return _HC_API_PythonPackage.FloatVector_insert(self, *args)

    def reserve(self, n):
        return _HC_API_PythonPackage.FloatVector_reserve(self, n)

    def capacity(self):
        return _HC_API_PythonPackage.FloatVector_capacity(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_FloatVector

# Register FloatVector in _HC_API_PythonPackage:
_HC_API_PythonPackage.FloatVector_swigregister(FloatVector)


#Addition Python Code that swig will add to the python package and become part of controlAPI.py

#Python Function Calling C++ ControlApi::logLocation()
def pythonPrintLogFunction():
   print("Printing Log Location From Python: " + str(logLocation(0)))






HC_LOG_DEVICE_NAME_LEN = _HC_API_PythonPackage.HC_LOG_DEVICE_NAME_LEN

def throwTestException():
    r"""
    throw a test exception from the library
    :rtype: int
    :return: 
    """
    return _HC_API_PythonPackage.throwTestException()

def raiseTestSIGSEG():
    r"""
    raise a test SIGSEGV signal from the library
    :rtype: int
    :return: 
    """
    return _HC_API_PythonPackage.raiseTestSIGSEG()

def printTestMessage():
    r""" print a test message from the library"""
    return _HC_API_PythonPackage.printTestMessage()

def printTestErrorMessage():
    r""" print a test error message from the library"""
    return _HC_API_PythonPackage.printTestErrorMessage()

def printTestErrorThrowMessage():
    r""" print a test error message from the library and throw an exception"""
    return _HC_API_PythonPackage.printTestErrorThrowMessage()

def logLocation(index):
    r"""
    return the full path of the log location
    :type index: int
    :param index: the log location index (default 0)
    :rtype: string
    :return: the log location as a string.
    """
    return _HC_API_PythonPackage.logLocation(index)

def addLogPath(logFilePath):
    r"""
    Add a new log path for log files to be created in.
    :type logFilePath: string
    :param logFilePath:
    """
    return _HC_API_PythonPackage.addLogPath(logFilePath)

def getRuntimeLibraryPath():
    return _HC_API_PythonPackage.getRuntimeLibraryPath()

def getRuntimeDependancyPath():
    return _HC_API_PythonPackage.getRuntimeDependancyPath()
class HardwareInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    apiDeviceId = property(_HC_API_PythonPackage.HardwareInfo_apiDeviceId_get, _HC_API_PythonPackage.HardwareInfo_apiDeviceId_set)
    alias = property(_HC_API_PythonPackage.HardwareInfo_alias_get, _HC_API_PythonPackage.HardwareInfo_alias_set)

    def __init__(self):
        _HC_API_PythonPackage.HardwareInfo_swiginit(self, _HC_API_PythonPackage.new_HardwareInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_HardwareInfo

# Register HardwareInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.HardwareInfo_swigregister(HardwareInfo)
class PhysicalAxisControlInfo(object):
    r""" base class representing a physical axis (linear or rotational, with movement limits)"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    minPosLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_minPosLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_minPosLimit_set)
    maxPosLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_maxPosLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_maxPosLimit_set)
    minVelLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_minVelLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_minVelLimit_set)
    maxVelLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_maxVelLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_maxVelLimit_set)
    minAccLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_minAccLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_minAccLimit_set)
    maxAccLimit = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_maxAccLimit_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_maxAccLimit_set)
    isRadial = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_isRadial_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_isRadial_set)
    submittedToApi = property(_HC_API_PythonPackage.PhysicalAxisControlInfo_submittedToApi_get, _HC_API_PythonPackage.PhysicalAxisControlInfo_submittedToApi_set)

    def __init__(self):
        _HC_API_PythonPackage.PhysicalAxisControlInfo_swiginit(self, _HC_API_PythonPackage.new_PhysicalAxisControlInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_PhysicalAxisControlInfo

# Register PhysicalAxisControlInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.PhysicalAxisControlInfo_swigregister(PhysicalAxisControlInfo)
class CommandStateInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CommandStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CommandStateInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_CommandStateInfo
    percentFinished = property(_HC_API_PythonPackage.CommandStateInfo_percentFinished_get, _HC_API_PythonPackage.CommandStateInfo_percentFinished_set, doc=r"""
    <summary>
    percentage to command completion.
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.CommandStateInfo_swiginit(self, _HC_API_PythonPackage.new_CommandStateInfo())

# Register CommandStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.CommandStateInfo_swigregister(CommandStateInfo)
class ApiCommandPackage(object):
    r""" Base Class for command packages"""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ApiCommandPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ApiCommandPackage_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ApiCommandPackage
    alias = property(_HC_API_PythonPackage.ApiCommandPackage_alias_get, _HC_API_PythonPackage.ApiCommandPackage_alias_set, doc=r""" user definable unique alias for this command package""")

    def __init__(self):
        _HC_API_PythonPackage.ApiCommandPackage_swiginit(self, _HC_API_PythonPackage.new_ApiCommandPackage())

# Register ApiCommandPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.ApiCommandPackage_swigregister(ApiCommandPackage)
class DeviceCommandPackage(ApiCommandPackage):
    r"""
    Base Class containing command parameters needed to run a command for a device.
    The package is referenced during command updating. so parameters can be changed during command execution.
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DeviceCommandPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DeviceCommandPackage_className(self)

    def createSharedPtr(self):
        return _HC_API_PythonPackage.DeviceCommandPackage_createSharedPtr(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DeviceCommandPackage

    def cloneFrom(self, other):
        r"""
        clone from another device package - should be implemented for custom types.
        :type other: :py:class:`DeviceCommandPackage`
        :param other:
        """
        return _HC_API_PythonPackage.DeviceCommandPackage_cloneFrom(self, other)

    def prepareUpdatePackage(self):
        r"""
        Creates/Returns the DeviceCommandPackage to be used for updates to a running command. Update package will be a shallow copy of this package.
        It is expected that markUpdatePackageReady() be called after update package is altered.
        :rtype: :py:class:`DeviceCommandPackage`
        :return: DeviceCommandPackage*
        """
        return _HC_API_PythonPackage.DeviceCommandPackage_prepareUpdatePackage(self)

    def markUpdatePackageReady(self):
        r"""
        signal the update package is ready to be used in running commands.
        prepareUpdatePackage() should be called first.
        """
        return _HC_API_PythonPackage.DeviceCommandPackage_markUpdatePackageReady(self)
    continuous = property(_HC_API_PythonPackage.DeviceCommandPackage_continuous_get, _HC_API_PythonPackage.DeviceCommandPackage_continuous_set, doc=r"""
    set to true if command is a continous (async/time consuming) command or if it is desired that the command run indefinitely. (tracking command etc)
    set to false if the command should terminate once a target is reached.
    """)

    def __init__(self):
        _HC_API_PythonPackage.DeviceCommandPackage_swiginit(self, _HC_API_PythonPackage.new_DeviceCommandPackage())

# Register DeviceCommandPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.DeviceCommandPackage_swigregister(DeviceCommandPackage)
class MovementCommandPackage(DeviceCommandPackage):
    r""" Generic Movement Command Supported on moving devices"""

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.MovementCommandPackage_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.MovementCommandPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.MovementCommandPackage_className(self)

    def __init__(self):
        _HC_API_PythonPackage.MovementCommandPackage_swiginit(self, _HC_API_PythonPackage.new_MovementCommandPackage())
    __swig_destroy__ = _HC_API_PythonPackage.delete_MovementCommandPackage

    def cloneFrom(self, other):
        return _HC_API_PythonPackage.MovementCommandPackage_cloneFrom(self, other)
    Units_Millimeters = _HC_API_PythonPackage.MovementCommandPackage_Units_Millimeters
    Units_Degrees = _HC_API_PythonPackage.MovementCommandPackage_Units_Degrees
    disp_target = property(_HC_API_PythonPackage.MovementCommandPackage_disp_target_get, _HC_API_PythonPackage.MovementCommandPackage_disp_target_set, doc=r""" Position Target ex: (Millimeters)""")
    vel_target = property(_HC_API_PythonPackage.MovementCommandPackage_vel_target_get, _HC_API_PythonPackage.MovementCommandPackage_vel_target_set, doc=r""" Vel Target ex: (Millimeters/S)""")
    acc_target = property(_HC_API_PythonPackage.MovementCommandPackage_acc_target_get, _HC_API_PythonPackage.MovementCommandPackage_acc_target_set, doc=r""" Acc Target ex: (Millimeters/S^2)""")
    disp_absolute = property(_HC_API_PythonPackage.MovementCommandPackage_disp_absolute_get, _HC_API_PythonPackage.MovementCommandPackage_disp_absolute_set, doc=r""" whether position should be global to device or relative to starting position when command starts.""")
    trackDisp = property(_HC_API_PythonPackage.MovementCommandPackage_trackDisp_get, _HC_API_PythonPackage.MovementCommandPackage_trackDisp_set, doc=r""" Enable Track Displacement Target""")
    trackVel = property(_HC_API_PythonPackage.MovementCommandPackage_trackVel_get, _HC_API_PythonPackage.MovementCommandPackage_trackVel_set, doc=r""" Track Velocity Target (if vel_target is non-zero)""")
    trackAcc = property(_HC_API_PythonPackage.MovementCommandPackage_trackAcc_get, _HC_API_PythonPackage.MovementCommandPackage_trackAcc_set, doc=r""" Track Acceleration Target (if acc_target is non-zero)""")
    units = property(_HC_API_PythonPackage.MovementCommandPackage_units_get, _HC_API_PythonPackage.MovementCommandPackage_units_set, doc=r""" units""")

# Register MovementCommandPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.MovementCommandPackage_swigregister(MovementCommandPackage)
class MonitorCommandPackage(DeviceCommandPackage):
    r"""Base class command to get current state of device."""

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.MonitorCommandPackage_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.MonitorCommandPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.MonitorCommandPackage_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_MonitorCommandPackage

    def __init__(self):
        _HC_API_PythonPackage.MonitorCommandPackage_swiginit(self, _HC_API_PythonPackage.new_MonitorCommandPackage())

# Register MonitorCommandPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.MonitorCommandPackage_swigregister(MonitorCommandPackage)
class TimeDelayDeviceCommand(DeviceCommandPackage):
    r""" Command that adds a time delay."""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.TimeDelayDeviceCommand_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.TimeDelayDeviceCommand_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_TimeDelayDeviceCommand
    time_s = property(_HC_API_PythonPackage.TimeDelayDeviceCommand_time_s_get, _HC_API_PythonPackage.TimeDelayDeviceCommand_time_s_set, doc=r"""
    <summary>
    time in seconds to wait.
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.TimeDelayDeviceCommand_swiginit(self, _HC_API_PythonPackage.new_TimeDelayDeviceCommand())

# Register TimeDelayDeviceCommand in _HC_API_PythonPackage:
_HC_API_PythonPackage.TimeDelayDeviceCommand_swigregister(TimeDelayDeviceCommand)
class SynchronizeDeviceCommand(DeviceCommandPackage):
    r""" Command that synchronizes multiple commands to finish at a certain time"""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.SynchronizeDeviceCommand_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.SynchronizeDeviceCommand_className(self)

    def __init__(self):
        _HC_API_PythonPackage.SynchronizeDeviceCommand_swiginit(self, _HC_API_PythonPackage.new_SynchronizeDeviceCommand())
    __swig_destroy__ = _HC_API_PythonPackage.delete_SynchronizeDeviceCommand

# Register SynchronizeDeviceCommand in _HC_API_PythonPackage:
_HC_API_PythonPackage.SynchronizeDeviceCommand_swigregister(SynchronizeDeviceCommand)
class MovementStateInfo(CommandStateInfo):
    r""" base class for representing the movement state of a command at any time."""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.MovementStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.MovementStateInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_MovementStateInfo
    referencePos = property(_HC_API_PythonPackage.MovementStateInfo_referencePos_get, _HC_API_PythonPackage.MovementStateInfo_referencePos_set)
    currentTargetPos = property(_HC_API_PythonPackage.MovementStateInfo_currentTargetPos_get, _HC_API_PythonPackage.MovementStateInfo_currentTargetPos_set)
    currentPos = property(_HC_API_PythonPackage.MovementStateInfo_currentPos_get, _HC_API_PythonPackage.MovementStateInfo_currentPos_set)
    currentTargetVel = property(_HC_API_PythonPackage.MovementStateInfo_currentTargetVel_get, _HC_API_PythonPackage.MovementStateInfo_currentTargetVel_set)
    currentVel = property(_HC_API_PythonPackage.MovementStateInfo_currentVel_get, _HC_API_PythonPackage.MovementStateInfo_currentVel_set)
    currentTargetAcc = property(_HC_API_PythonPackage.MovementStateInfo_currentTargetAcc_get, _HC_API_PythonPackage.MovementStateInfo_currentTargetAcc_set)
    currentAcc = property(_HC_API_PythonPackage.MovementStateInfo_currentAcc_get, _HC_API_PythonPackage.MovementStateInfo_currentAcc_set)
    signedDir = property(_HC_API_PythonPackage.MovementStateInfo_signedDir_get, _HC_API_PythonPackage.MovementStateInfo_signedDir_set)
    homing = property(_HC_API_PythonPackage.MovementStateInfo_homing_get, _HC_API_PythonPackage.MovementStateInfo_homing_set)
    isHomed = property(_HC_API_PythonPackage.MovementStateInfo_isHomed_get, _HC_API_PythonPackage.MovementStateInfo_isHomed_set)

    def __init__(self):
        _HC_API_PythonPackage.MovementStateInfo_swiginit(self, _HC_API_PythonPackage.new_MovementStateInfo())

# Register MovementStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.MovementStateInfo_swigregister(MovementStateInfo)
class CommandStatusControlMethods(object):
    r""" Base class for implementing methods for CommandStatus objects."""

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

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CommandStatusControlMethods_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CommandStatusControlMethods_className(self)

    def runFull(self):
        r"""
        <summary>
        initializes, and runs the command until it stops (blocking)
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_runFull(self)

    def runASync(self):
        r"""
        <summary>
        initialize and start the command async.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_runASync(self)

    def initialize(self):
        r"""
        <summary>
        Start the command by internally initializing the thread, binding to the device, and ensuring it is ready to be updated.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_initialize(self)

    def update(self, stepped=False):
        r"""
        <summary>
        update the command by allowing it to begin.  if stepped = true, will begin to perform 1 update. if stepped = false, will update until finished.
        <summary>
        <param name="stepped"><param>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_update(self, stepped)

    def waitUpdateReady(self):
        r"""
        <summary>
        Wait until command is ready to begin a update step
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_waitUpdateReady(self)

    def waitUpdateReadyOrFinished(self):
        r"""
        <summary>
        Wait until command is ready to begin an update step or it is finished.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_waitUpdateReadyOrFinished(self)

    def waitFinished(self):
        r"""
        <summary>
        Wait for the command to finish.
        <summary>
        """
        return _HC_API_PythonPackage.CommandStatusControlMethods_waitFinished(self)

    def stop(self):
        r""" End the command (cancel)"""
        return _HC_API_PythonPackage.CommandStatusControlMethods_stop(self)

    def isBusy(self):
        r""" returns true if the command is currently running"""
        return _HC_API_PythonPackage.CommandStatusControlMethods_isBusy(self)

    def isUpdateStepReady(self):
        return _HC_API_PythonPackage.CommandStatusControlMethods_isUpdateStepReady(self)

    def isFinished(self):
        r""" returns true if the command has finished. (normally finished or cancelled)."""
        return _HC_API_PythonPackage.CommandStatusControlMethods_isFinished(self)

    def isCancelled(self):
        r""" returns true if the command was cancelled."""
        return _HC_API_PythonPackage.CommandStatusControlMethods_isCancelled(self)

    def isSuccessful(self):
        return _HC_API_PythonPackage.CommandStatusControlMethods_isSuccessful(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_CommandStatusControlMethods

# Register CommandStatusControlMethods in _HC_API_PythonPackage:
_HC_API_PythonPackage.CommandStatusControlMethods_swigregister(CommandStatusControlMethods)
class CommandStatus(CommandStatusControlMethods):
    r""" Command Status Object for tracking the current state of a queued or executing command."""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CommandStatus_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CommandStatus_className(self)

    def __init__(self):
        _HC_API_PythonPackage.CommandStatus_swiginit(self, _HC_API_PythonPackage.new_CommandStatus())
    __swig_destroy__ = _HC_API_PythonPackage.delete_CommandStatus

    def runFull(self):
        return _HC_API_PythonPackage.CommandStatus_runFull(self)

    def runASync(self):
        return _HC_API_PythonPackage.CommandStatus_runASync(self)

    def initialize(self):
        return _HC_API_PythonPackage.CommandStatus_initialize(self)

    def update(self, stepped=False):
        return _HC_API_PythonPackage.CommandStatus_update(self, stepped)

    def waitUpdateReady(self):
        return _HC_API_PythonPackage.CommandStatus_waitUpdateReady(self)

    def waitUpdateReadyOrFinished(self):
        return _HC_API_PythonPackage.CommandStatus_waitUpdateReadyOrFinished(self)

    def waitFinished(self):
        return _HC_API_PythonPackage.CommandStatus_waitFinished(self)

    def stop(self):
        return _HC_API_PythonPackage.CommandStatus_stop(self)

    def isBusy(self):
        return _HC_API_PythonPackage.CommandStatus_isBusy(self)

    def isUpdateStepReady(self):
        return _HC_API_PythonPackage.CommandStatus_isUpdateStepReady(self)

    def isFinished(self):
        return _HC_API_PythonPackage.CommandStatus_isFinished(self)

    def isCancelled(self):
        return _HC_API_PythonPackage.CommandStatus_isCancelled(self)

    def isSuccessful(self):
        return _HC_API_PythonPackage.CommandStatus_isSuccessful(self)

    def apiId(self):
        return _HC_API_PythonPackage.CommandStatus_apiId(self)

    def deviceApiId(self):
        return _HC_API_PythonPackage.CommandStatus_deviceApiId(self)

    def stateInfo(self):
        r"""
        <summary>
        The command state information associated with the command.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatus_stateInfo(self)

    def commandPackage(self):
        r"""
        <summary>
        The command package associated with the command.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatus_commandPackage(self)

    def controlSystem(self):
        r"""
        <summary>
        The control system this command status belongs to.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatus_controlSystem(self)

    def deviceInfo(self):
        r"""
        <summary>
        The device this command status is associated with.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatus_deviceInfo(self)

    def deviceController(self):
        r"""
        <summary>
        The device controller this command status is associated with.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.CommandStatus_deviceController(self)
    alias = property(_HC_API_PythonPackage.CommandStatus_alias_get, _HC_API_PythonPackage.CommandStatus_alias_set, doc=r""" The unique alias for this command.""")

# Register CommandStatus in _HC_API_PythonPackage:
_HC_API_PythonPackage.CommandStatus_swigregister(CommandStatus)
class DeviceInfo(HardwareInfo):
    r""" Base Class for describing a device to be attached to a DeviceController"""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DeviceInfo_className(self)

    def __init__(self):
        _HC_API_PythonPackage.DeviceInfo_swiginit(self, _HC_API_PythonPackage.new_DeviceInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_DeviceInfo

    def preLoopCommandCheck(self, checkCancelled=True):
        return _HC_API_PythonPackage.DeviceInfo_preLoopCommandCheck(self, checkCancelled)

    def isConnected(self):
        r""" Returns true is the device is currently connected."""
        return _HC_API_PythonPackage.DeviceInfo_isConnected(self)

    def setEnableCommandLogging(self, enable):
        r"""
        set the device to log messages to the console. (default true)
        :type enable: boolean
        :param enable:
        """
        return _HC_API_PythonPackage.DeviceInfo_setEnableCommandLogging(self, enable)

    def setCommandLoggingLevel(self, level):
        r"""
        Set the command logging level, 0 - regular, 1 - more detail, 2 - even more detail, etc.
        :type level: int
        :param level:
        """
        return _HC_API_PythonPackage.DeviceInfo_setCommandLoggingLevel(self, level)

    def commandLoggingEnabled(self):
        return _HC_API_PythonPackage.DeviceInfo_commandLoggingEnabled(self)

    def commandLoggingLevel(self):
        return _HC_API_PythonPackage.DeviceInfo_commandLoggingLevel(self)

    def initializeCommand(self, commandPackage):
        return _HC_API_PythonPackage.DeviceInfo_initializeCommand(self, commandPackage)

    def addCommandGeneric(self, package):
        return _HC_API_PythonPackage.DeviceInfo_addCommandGeneric(self, package)

    def deviceController(self):
        r""" access to owning controller."""
        return _HC_API_PythonPackage.DeviceInfo_deviceController(self)

    def controlSystem(self):
        r""" access to owning control system."""
        return _HC_API_PythonPackage.DeviceInfo_controlSystem(self)

# Register DeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.DeviceInfo_swigregister(DeviceInfo)
class CommandCallbacks(object):
    r""" DEPRECIATED Base Clase to be overridden by user exposing methods called on command state changes."""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CommandCallbacks_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CommandCallbacks_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_CommandCallbacks

    def onCommandFinished(self, commandStatus, deviceInfo):
        r""" Called when a Command Finishes."""
        return _HC_API_PythonPackage.CommandCallbacks_onCommandFinished(self, commandStatus, deviceInfo)

    def onCommandUpdate(self, commandStatus, deviceInfo):
        r""" Called during command execution"""
        return _HC_API_PythonPackage.CommandCallbacks_onCommandUpdate(self, commandStatus, deviceInfo)

    def __init__(self):
        _HC_API_PythonPackage.CommandCallbacks_swiginit(self, _HC_API_PythonPackage.new_CommandCallbacks())

# Register CommandCallbacks in _HC_API_PythonPackage:
_HC_API_PythonPackage.CommandCallbacks_swigregister(CommandCallbacks)
class LoggerFunctionality(object):
    r""" base class implementing logger functionality for classes."""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LoggerFunctionality_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LoggerFunctionality_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LoggerFunctionality

    def getLogger(self):
        return _HC_API_PythonPackage.LoggerFunctionality_getLogger(self)

    def loggerName(self):
        return _HC_API_PythonPackage.LoggerFunctionality_loggerName(self)

    def __init__(self):
        _HC_API_PythonPackage.LoggerFunctionality_swiginit(self, _HC_API_PythonPackage.new_LoggerFunctionality())

# Register LoggerFunctionality in _HC_API_PythonPackage:
_HC_API_PythonPackage.LoggerFunctionality_swigregister(LoggerFunctionality)
class ControlSystem(LoggerFunctionality):
    r"""
    Primary class for managing upper-level control over a multi-axis system with different devices.
    Supports addition of Devices, Controllers, and Control/Commands
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ControlSystem_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ControlSystem_className(self)

    def __init__(self, *args):
        _HC_API_PythonPackage.ControlSystem_swiginit(self, _HC_API_PythonPackage.new_ControlSystem(*args))
    __swig_destroy__ = _HC_API_PythonPackage.delete_ControlSystem

    def addDeviceController(self, controller):
        r""" Add a device controller to the control system."""
        return _HC_API_PythonPackage.ControlSystem_addDeviceController(self, controller)

    def initializeDevices(self):
        r""" initFriendlyNameBuffer (start initial communication and do checks) on all added controllers/devices"""
        return _HC_API_PythonPackage.ControlSystem_initializeDevices(self)

    def initializeController(self, controller):
        r""" initFriendlyNameBuffer an added device controller."""
        return _HC_API_PythonPackage.ControlSystem_initializeController(self, controller)

    def unInitialize(self):
        r"""
        <summary>
        De initialize the control system.  disconnecting all controllers and devices.  user created controllers and devices should remain allocated while this function
        is called - then can be freed/released afterwards.
        <summary>
        """
        return _HC_API_PythonPackage.ControlSystem_unInitialize(self)

    def muteConsole(self):
        r""" Mute info messages on console."""
        return _HC_API_PythonPackage.ControlSystem_muteConsole(self)

    def unMuteConsole(self):
        r""" UnMute info message on console."""
        return _HC_API_PythonPackage.ControlSystem_unMuteConsole(self)

    def delay(self, *args):
        r"""
        *Overload 1:*
        Add a time delay command to a device

        |

        *Overload 2:*
        Add a time delay command to a device
        """
        return _HC_API_PythonPackage.ControlSystem_delay(self, *args)

    def addDeviceCommand(self, device, package):
        r""" Add a command to a device."""
        return _HC_API_PythonPackage.ControlSystem_addDeviceCommand(self, device, package)

    def addDeviceCommandAlias(self, deviceAlias, package):
        r""" Add a command to a device using device alias string"""
        return _HC_API_PythonPackage.ControlSystem_addDeviceCommandAlias(self, deviceAlias, package)

    def addDeviceCommandDevId(self, deviceId, package):
        r""" Add a command to a device using device id"""
        return _HC_API_PythonPackage.ControlSystem_addDeviceCommandDevId(self, deviceId, package)

    def getDeviceFromAlias(self, deviceAlias):
        r""" Get a device from its alias string"""
        return _HC_API_PythonPackage.ControlSystem_getDeviceFromAlias(self, deviceAlias)

    def getControllerFromAlias(self, controllerAlias):
        r""" Get a controller from its alias string"""
        return _HC_API_PythonPackage.ControlSystem_getControllerFromAlias(self, controllerAlias)

    def runFullCommandListSeq(self, commandList):
        r"""
        <summary>
        Run Commands in order, one after another, fully
        <summary>
        <param name="commandList"><param>
        """
        return _HC_API_PythonPackage.ControlSystem_runFullCommandListSeq(self, commandList)

    def runFullCommandListParallel(self, commandList):
        r"""
        <summary>
        Run Commands in parallel
        <summary>
        <param name="commandList"><param>
        """
        return _HC_API_PythonPackage.ControlSystem_runFullCommandListParallel(self, commandList)

    def runASyncCommandList(self, commandList):
        r"""
        <summary>
        Start the list of commands running async, returns immediately.
        <summary>
        <param name="commandList"><param>
        """
        return _HC_API_PythonPackage.ControlSystem_runASyncCommandList(self, commandList)

    def waitFinishedCommandList(self, commandList):
        r"""
        <summary>
        Wait for the list of commands to complete
        <summary>
        <param name="commandList"><param>
        """
        return _HC_API_PythonPackage.ControlSystem_waitFinishedCommandList(self, commandList)

    def setCommandCallback(self, callbackObj):
        r""" Attach a CommandCallbacks object to the ControlSystem."""
        return _HC_API_PythonPackage.ControlSystem_setCommandCallback(self, callbackObj)

# Register ControlSystem in _HC_API_PythonPackage:
_HC_API_PythonPackage.ControlSystem_swigregister(ControlSystem)
class DeviceController(LoggerFunctionality):
    r""" Base Class For Controlling Devices"""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DeviceController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DeviceController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DeviceController

    def checkCommandPackage(self, deviceId, package):
        r""" check validity of command package"""
        return _HC_API_PythonPackage.DeviceController_checkCommandPackage(self, deviceId, package)

    def addDeviceInfo(self, dev):
        r"""
        <summary>
        Add a device to the controller.
        <summary>
        <param name="dev"><param>
        """
        return _HC_API_PythonPackage.DeviceController_addDeviceInfo(self, dev)

    def removeDeviceInfo(self, dev):
        r""" Remove an already added device."""
        return _HC_API_PythonPackage.DeviceController_removeDeviceInfo(self, dev)

    def setDisconnectCallback(self, callback):
        r""" set a disconnected callback function to be called when the controller is disconnected."""
        return _HC_API_PythonPackage.DeviceController_setDisconnectCallback(self, callback)
    alias = property(_HC_API_PythonPackage.DeviceController_alias_get, _HC_API_PythonPackage.DeviceController_alias_set, doc=r""" Alias of the controller""")
    port = property(_HC_API_PythonPackage.DeviceController_port_get, _HC_API_PythonPackage.DeviceController_port_set, doc=r''' port for connecting, if the device is a serial device this can be "COM3" or "/dev/tty.***"''')

    def disconnect(self, expected=False):
        r"""
        disconnect the controller, should handle both a manual disconnect and could be called from a comm error disconnect.
        set expected to false if called from a timeout error or unknown disconnect event. - error messages are printed.
        set expected to true if a manual disconnection is wanted.- info messages are printed.
        """
        return _HC_API_PythonPackage.DeviceController_disconnect(self, expected)

    def isConnected(self):
        r""" returns true if the controller is currently connected."""
        return _HC_API_PythonPackage.DeviceController_isConnected(self)

    def apiId(self):
        r""" the assigned Api Id of the controller"""
        return _HC_API_PythonPackage.DeviceController_apiId(self)

    def setSimulated(self, simulated):
        r"""
        set the simulated flag on the controller - simulated controllers can simulate interaction with attached devices.
        can only be set before the controller is initialized.
        :type simulated: boolean
        :param simulated:
        """
        return _HC_API_PythonPackage.DeviceController_setSimulated(self, simulated)

    def isSimulated(self):
        r"""
        return if the controller is simulated.
        :rtype: boolean
        :return: 
        """
        return _HC_API_PythonPackage.DeviceController_isSimulated(self)

    def __init__(self):
        _HC_API_PythonPackage.DeviceController_swiginit(self, _HC_API_PythonPackage.new_DeviceController())

# Register DeviceController in _HC_API_PythonPackage:
_HC_API_PythonPackage.DeviceController_swigregister(DeviceController)

def As_MovementStateInfo(obj):
    r""" Dynamic Cast a CommandStateInfo pointer into a MovementStateInfo pointer"""
    return _HC_API_PythonPackage.As_MovementStateInfo(obj)

def As_MovementCommandPackage(obj):
    return _HC_API_PythonPackage.As_MovementCommandPackage(obj)
class Vector3D(object):
    r""" primative 3D Vector"""

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

    def __init__(self, *args):
        _HC_API_PythonPackage.Vector3D_swiginit(self, _HC_API_PythonPackage.new_Vector3D(*args))
    x = property(_HC_API_PythonPackage.Vector3D_x_get, _HC_API_PythonPackage.Vector3D_x_set)
    y = property(_HC_API_PythonPackage.Vector3D_y_get, _HC_API_PythonPackage.Vector3D_y_set)
    z = property(_HC_API_PythonPackage.Vector3D_z_get, _HC_API_PythonPackage.Vector3D_z_set)

    def IsZero(self):
        r"""
        <summary>
        return true if vector is unset (0,0,0) (no fuzzy compare)
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.Vector3D_IsZero(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_Vector3D

# Register Vector3D in _HC_API_PythonPackage:
_HC_API_PythonPackage.Vector3D_swigregister(Vector3D)
class HardwareDeviceController(DeviceController):
    r""" <summary> Base Class for hardware controllers."""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.HardwareDeviceController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.HardwareDeviceController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_HardwareDeviceController

    def __init__(self):
        _HC_API_PythonPackage.HardwareDeviceController_swiginit(self, _HC_API_PythonPackage.new_HardwareDeviceController())

# Register HardwareDeviceController in _HC_API_PythonPackage:
_HC_API_PythonPackage.HardwareDeviceController_swigregister(HardwareDeviceController)
class DMXDeviceInfo(DeviceInfo):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DMXDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DMXDeviceInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceInfo
    DMXBaseAddress = property(_HC_API_PythonPackage.DMXDeviceInfo_DMXBaseAddress_get, _HC_API_PythonPackage.DMXDeviceInfo_DMXBaseAddress_set)
    numChannels = property(_HC_API_PythonPackage.DMXDeviceInfo_numChannels_get, _HC_API_PythonPackage.DMXDeviceInfo_numChannels_set)

    def __init__(self):
        _HC_API_PythonPackage.DMXDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceInfo())

# Register DMXDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.DMXDeviceInfo_swigregister(DMXDeviceInfo)
class DMXDeviceCommandPackage(DeviceCommandPackage):
    r"""
    <summary>
    base class for dmx command packages
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.DMXDeviceCommandPackage_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DMXDeviceCommandPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DMXDeviceCommandPackage_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommandPackage

    def __init__(self):
        _HC_API_PythonPackage.DMXDeviceCommandPackage_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommandPackage())

# Register DMXDeviceCommandPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.DMXDeviceCommandPackage_swigregister(DMXDeviceCommandPackage)
class DMXDeviceCommandLightingPackage(DMXDeviceCommandPackage):
    r"""
    <summary>
    base class for dmx lighting command packages
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommandLightingPackage

    def __init__(self):
        _HC_API_PythonPackage.DMXDeviceCommandLightingPackage_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommandLightingPackage())

# Register DMXDeviceCommandLightingPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.DMXDeviceCommandLightingPackage_swigregister(DMXDeviceCommandLightingPackage)
class DMXDeviceCommand_HSLColor8Bit(DMXDeviceCommandLightingPackage):
    r"""
    <summary>
    command to set the hsl color of a dmx lighting device
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommand_HSLColor8Bit
    h = property(_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_h_get, _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_h_set, doc=r"""
    <summary>
    hue
    <summary>
    """)
    s = property(_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_s_get, _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_s_set, doc=r"""
    <summary>
    saturation
    <summary>
    """)
    l = property(_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_l_get, _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_l_set, doc=r"""
    <summary>
    lightness
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommand_HSLColor8Bit())

# Register DMXDeviceCommand_HSLColor8Bit in _HC_API_PythonPackage:
_HC_API_PythonPackage.DMXDeviceCommand_HSLColor8Bit_swigregister(DMXDeviceCommand_HSLColor8Bit)
class DMXDeviceCommand_RGBColor8Bit(DMXDeviceCommandLightingPackage):
    r"""
    <summary>
    command to set the rgb color of a dmx lighting device
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommand_RGBColor8Bit

    def cloneFrom(self, other):
        return _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_cloneFrom(self, other)
    red = property(_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_red_get, _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_red_set)
    green = property(_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_green_get, _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_green_set)
    blue = property(_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_blue_get, _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_blue_set)

    def __init__(self):
        _HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommand_RGBColor8Bit())

# Register DMXDeviceCommand_RGBColor8Bit in _HC_API_PythonPackage:
_HC_API_PythonPackage.DMXDeviceCommand_RGBColor8Bit_swigregister(DMXDeviceCommand_RGBColor8Bit)
class DMXDeviceCommand_SetPersonality(DMXDeviceCommandPackage):
    r"""
    <summary>
    command to set the dmx personality of a dmx lighting device
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DMXDeviceCommand_SetPersonality
    personalityIndex = property(_HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_personalityIndex_get, _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_personalityIndex_set)

    def __init__(self):
        _HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_swiginit(self, _HC_API_PythonPackage.new_DMXDeviceCommand_SetPersonality())

# Register DMXDeviceCommand_SetPersonality in _HC_API_PythonPackage:
_HC_API_PythonPackage.DMXDeviceCommand_SetPersonality_swigregister(DMXDeviceCommand_SetPersonality)
class dmxController(HardwareDeviceController):
    r"""
    <summary>
    controller base class for dmx devices
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.dmxController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.dmxController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_dmxController

    def __init__(self):
        _HC_API_PythonPackage.dmxController_swiginit(self, _HC_API_PythonPackage.new_dmxController())

# Register dmxController in _HC_API_PythonPackage:
_HC_API_PythonPackage.dmxController_swigregister(dmxController)
class EntTecController(dmxController):
    r"""
    <summary>
    controller for EntTec DMX USB Pro
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.EntTecController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.EntTecController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_EntTecController

    def __init__(self):
        _HC_API_PythonPackage.EntTecController_swiginit(self, _HC_API_PythonPackage.new_EntTecController())

# Register EntTecController in _HC_API_PythonPackage:
_HC_API_PythonPackage.EntTecController_swigregister(EntTecController)
KinoFlo_P1_CCT_8b_3 = _HC_API_PythonPackage.KinoFlo_P1_CCT_8b_3
KinoFlo_P2_GEL_8b_6 = _HC_API_PythonPackage.KinoFlo_P2_GEL_8b_6
KinoFlo_P3_RGB_8b_6 = _HC_API_PythonPackage.KinoFlo_P3_RGB_8b_6
KinoFlo_P4_FX_8b_8 = _HC_API_PythonPackage.KinoFlo_P4_FX_8b_8
KinoFlo_P5_xy_8b_3 = _HC_API_PythonPackage.KinoFlo_P5_xy_8b_3
KinoFlo_P6_CCT_16b_4 = _HC_API_PythonPackage.KinoFlo_P6_CCT_16b_4
KinoFlo_P7_GEL_16b_7 = _HC_API_PythonPackage.KinoFlo_P7_GEL_16b_7
KinoFlo_P8_RGB_16b_7 = _HC_API_PythonPackage.KinoFlo_P8_RGB_16b_7
KinoFlo_P9_FX_16b_9 = _HC_API_PythonPackage.KinoFlo_P9_FX_16b_9
KinoFlo_P10_xy_16b_4 = _HC_API_PythonPackage.KinoFlo_P10_xy_16b_4
KinoFlo_P11_CCT_8b_3 = _HC_API_PythonPackage.KinoFlo_P11_CCT_8b_3
KinoFlo_P12_CCT_16b_5 = _HC_API_PythonPackage.KinoFlo_P12_CCT_16b_5
KinoFlo_P13_Gel_8b_3 = _HC_API_PythonPackage.KinoFlo_P13_Gel_8b_3
KinoFlo_P14_Gel_16b_5 = _HC_API_PythonPackage.KinoFlo_P14_Gel_16b_5
KinoFlo_P15_HS_8b_4 = _HC_API_PythonPackage.KinoFlo_P15_HS_8b_4
KinoFlo_P16_HS_16b_8 = _HC_API_PythonPackage.KinoFlo_P16_HS_16b_8
KinoFlo_P17_RGB_8b_5 = _HC_API_PythonPackage.KinoFlo_P17_RGB_8b_5
KinoFlo_P18_RGB_16b_10 = _HC_API_PythonPackage.KinoFlo_P18_RGB_16b_10
KinoFlo_P19_CIE_xy_8b_3 = _HC_API_PythonPackage.KinoFlo_P19_CIE_xy_8b_3
KinoFlo_P20_CIE_xy_16b_6 = _HC_API_PythonPackage.KinoFlo_P20_CIE_xy_16b_6
KinoFlo_P21_FX_8b_8 = _HC_API_PythonPackage.KinoFlo_P21_FX_8b_8
KinoFlo_P22_FX_16b_10 = _HC_API_PythonPackage.KinoFlo_P22_FX_16b_10
KinoFlo_P23_CCT_AND_HS_8b_7 = _HC_API_PythonPackage.KinoFlo_P23_CCT_AND_HS_8b_7
KinoFlo_P24_CCT_AND_HS_16b_13 = _HC_API_PythonPackage.KinoFlo_P24_CCT_AND_HS_16b_13
KinoFlo_P25_CCT_AND_RGB_8b_8 = _HC_API_PythonPackage.KinoFlo_P25_CCT_AND_RGB_8b_8
KinoFlo_P26_CCT_AND_RGB_16b_15 = _HC_API_PythonPackage.KinoFlo_P26_CCT_AND_RGB_16b_15
KinoFlo_P27_xy1_AND_xy2_8b_6 = _HC_API_PythonPackage.KinoFlo_P27_xy1_AND_xy2_8b_6
KinoFlo_P28_xy1_AND_xy2_16b_12 = _HC_API_PythonPackage.KinoFlo_P28_xy1_AND_xy2_16b_12
KinoFlo_P29_CCT_AND_TDRGB_8b_9 = _HC_API_PythonPackage.KinoFlo_P29_CCT_AND_TDRGB_8b_9
KinoFlo_P30_CCT_AND_TDRGB_16b_15 = _HC_API_PythonPackage.KinoFlo_P30_CCT_AND_TDRGB_16b_15
class KinoFloDeviceCommand_RGBColor8Bit(DMXDeviceCommand_RGBColor8Bit):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def createSharedPtr(self):
        return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_KinoFloDeviceCommand_RGBColor8Bit

    def cloneFrom(self, other):
        return _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_cloneFrom(self, other)
    dimmer = property(_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_dimmer_get, _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_dimmer_set)
    cct = property(_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_cct_get, _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_cct_set)
    greenMagenta = property(_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_greenMagenta_get, _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_greenMagenta_set)

    def __init__(self):
        _HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_swiginit(self, _HC_API_PythonPackage.new_KinoFloDeviceCommand_RGBColor8Bit())

# Register KinoFloDeviceCommand_RGBColor8Bit in _HC_API_PythonPackage:
_HC_API_PythonPackage.KinoFloDeviceCommand_RGBColor8Bit_swigregister(KinoFloDeviceCommand_RGBColor8Bit)
cvar = _HC_API_PythonPackage.cvar
KinoFlo_NALPCODE = cvar.KinoFlo_NALPCODE

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.KinoFloDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.KinoFloDeviceInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_KinoFloDeviceInfo

    def __init__(self):
        _HC_API_PythonPackage.KinoFloDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_KinoFloDeviceInfo())

# Register KinoFloDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.KinoFloDeviceInfo_swigregister(KinoFloDeviceInfo)
class LiftingColumnMovementStateInfo(MovementStateInfo):
    r"""
    <summary>
    Lifting Column Movement State Info
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnMovementStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnMovementStateInfo_className(self)
    isStalled = property(_HC_API_PythonPackage.LiftingColumnMovementStateInfo_isStalled_get, _HC_API_PythonPackage.LiftingColumnMovementStateInfo_isStalled_set, doc=r"""
    <summary>
    indicates if the column has stalled (normal cases: at lower limit or upper limit - or under high load)
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnMovementStateInfo_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnMovementStateInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnMovementStateInfo

# Register LiftingColumnMovementStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnMovementStateInfo_swigregister(LiftingColumnMovementStateInfo)
class LiftingColumnCommandStatus(CommandStatus):
    r"""
    <summary>
    Lifting Column Command Status
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnCommandStatus_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnCommandStatus_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandStatus

    def stateInfo(self):
        return _HC_API_PythonPackage.LiftingColumnCommandStatus_stateInfo(self)

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnCommandStatus_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandStatus())

# Register LiftingColumnCommandStatus in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnCommandStatus_swigregister(LiftingColumnCommandStatus)
class LiftingColumnCommandMovementPackage(MovementCommandPackage):
    r"""
    <summary>

    Movement command for roboclaw.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandMovementPackage

    def cloneFrom(self, other):
        return _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_cloneFrom(self, other)
    expectStall = property(_HC_API_PythonPackage.LiftingColumnCommandMovementPackage_expectStall_get, _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_expectStall_set, doc=r"""
    <summary>
    stall expected flag - set to true if expecting a stall. (useful to home against mechanical limit)
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnCommandMovementPackage_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandMovementPackage())

# Register LiftingColumnCommandMovementPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnCommandMovementPackage_swigregister(LiftingColumnCommandMovementPackage)
class LiftingColumnCommandSetEncoderPos(DeviceCommandPackage):
    r"""
    <summary>
    Set the Internal Encoder Count of the RoboClaw
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandSetEncoderPos
    counts = property(_HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_counts_get, _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_counts_set)

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandSetEncoderPos())

# Register LiftingColumnCommandSetEncoderPos in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnCommandSetEncoderPos_swigregister(LiftingColumnCommandSetEncoderPos)
class LiftingColumnCommandGetEncoderPos(DeviceCommandPackage):
    r"""
    <summary>
    Get the Internal Encoder Count of the RoboClaw
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnCommandGetEncoderPos

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnCommandGetEncoderPos())

# Register LiftingColumnCommandGetEncoderPos in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnCommandGetEncoderPos_swigregister(LiftingColumnCommandGetEncoderPos)
class LiftingColumnDeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the Lifting Column
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LiftingColumnDeviceInfo_addCommand(self, package)

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnDeviceInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnDeviceInfo
    roboClawAddress = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_roboClawAddress_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_roboClawAddress_set)
    QPSS = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_QPSS_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_QPSS_set)
    encoderDeadZone = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_encoderDeadZone_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_encoderDeadZone_set)
    mm_s_p_duty = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_mm_s_p_duty_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_mm_s_p_duty_set, doc=r"""
    <summary>
    (millimeters/s)/(dutyCycle) ratio
    <summary>
    """)
    maxDutyCycle = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_maxDutyCycle_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_maxDutyCycle_set, doc=r"""
    <summary>
    duty cycle (power factor) (0 - 100)
    <summary>
    """)
    countsPerMM = property(_HC_API_PythonPackage.LiftingColumnDeviceInfo_countsPerMM_get, _HC_API_PythonPackage.LiftingColumnDeviceInfo_countsPerMM_set, doc=r"""
    <summary>
    Counts Per millimeter
    <summary>
    """)

# Register LiftingColumnDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnDeviceInfo_swigregister(LiftingColumnDeviceInfo)
class LiftingColumnController(HardwareDeviceController):
    r"""
    <summary>
    controller for Lifting Column
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LiftingColumnController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LiftingColumnController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LiftingColumnController

    def __init__(self):
        _HC_API_PythonPackage.LiftingColumnController_swiginit(self, _HC_API_PythonPackage.new_LiftingColumnController())

# Register LiftingColumnController in _HC_API_PythonPackage:
_HC_API_PythonPackage.LiftingColumnController_swigregister(LiftingColumnController)
class PheonixMecanoActuator(LiftingColumnDeviceInfo):
    r"""
    <summary>
    Device Info for the Pheonix Mecano Actuator (DEPRECATED)
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.PheonixMecanoActuator_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.PheonixMecanoActuator_className(self)

    def __init__(self):
        _HC_API_PythonPackage.PheonixMecanoActuator_swiginit(self, _HC_API_PythonPackage.new_PheonixMecanoActuator())
    __swig_destroy__ = _HC_API_PythonPackage.delete_PheonixMecanoActuator

# Register PheonixMecanoActuator in _HC_API_PythonPackage:
_HC_API_PythonPackage.PheonixMecanoActuator_swigregister(PheonixMecanoActuator)
ExoLightDriveMode_DC = _HC_API_PythonPackage.ExoLightDriveMode_DC
ExoLightDriveMode_Strobe = _HC_API_PythonPackage.ExoLightDriveMode_Strobe
ExoLightDriveMode_Voltage = _HC_API_PythonPackage.ExoLightDriveMode_Voltage
TriggerType_Internal = _HC_API_PythonPackage.TriggerType_Internal
TriggerType_External = _HC_API_PythonPackage.TriggerType_External
class ExoLightCommand_SetLighting(DeviceCommandPackage):
    r"""
    <summary>
    Command to set the lighting of a ExoLight device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ExoLightCommand_SetLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetLighting
    outputEnabled = property(_HC_API_PythonPackage.ExoLightCommand_SetLighting_outputEnabled_get, _HC_API_PythonPackage.ExoLightCommand_SetLighting_outputEnabled_set)

    def __init__(self):
        _HC_API_PythonPackage.ExoLightCommand_SetLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetLighting())

# Register ExoLightCommand_SetLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.ExoLightCommand_SetLighting_swigregister(ExoLightCommand_SetLighting)
class ExoLightCommand_SetDCLighting(ExoLightCommand_SetLighting):
    r"""
    <summary>
    Command to set the lighting (DC current drive mode) of a ExoLight device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetDCLighting
    intensityPercent = property(_HC_API_PythonPackage.ExoLightCommand_SetDCLighting_intensityPercent_get, _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_intensityPercent_set, doc=r"""
    <summary>
    percentage of range [20mA to maxMilliAmpsDCMode] to drive the light in DC mode
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ExoLightCommand_SetDCLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetDCLighting())

# Register ExoLightCommand_SetDCLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.ExoLightCommand_SetDCLighting_swigregister(ExoLightCommand_SetDCLighting)
class ExoLightCommand_SetStrobeLighting(ExoLightCommand_SetLighting):
    r"""
    <summary>
    Command to set the lighting (strobe mode) of a ExoLight device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetStrobeLighting
    strobeCurrentMilliAmps = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeCurrentMilliAmps_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeCurrentMilliAmps_set, doc=r"""
    <summary>
    DC Amperage to drive the led (milliamps)

    <summary>
    """)
    strobePulseWidthMicroSec = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobePulseWidthMicroSec_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobePulseWidthMicroSec_set, doc=r"""
    <summary>
    pulse width micro seconds

    <summary>
    """)
    strobeTriggerPeriodMicroSec = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerPeriodMicroSec_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerPeriodMicroSec_set, doc=r"""
    <summary>
    trigger period in micro seconds

    <summary>
    """)
    strobeTriggerDelayMicroSec = property(_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerDelayMicroSec_get, _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_strobeTriggerDelayMicroSec_set, doc=r"""
    <summary>
    strobe trigger delay in microsecs
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetStrobeLighting())

# Register ExoLightCommand_SetStrobeLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.ExoLightCommand_SetStrobeLighting_swigregister(ExoLightCommand_SetStrobeLighting)
class ExoLightCommand_SetVoltageLighting(ExoLightCommand_SetLighting):
    r"""
    <summary>
    Command to set the lighting (voltage mode) of a ExoLight device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ExoLightCommand_SetVoltageLighting
    voltage = property(_HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_voltage_get, _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_voltage_set, doc=r"""
    <summary>
    output voltage
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_swiginit(self, _HC_API_PythonPackage.new_ExoLightCommand_SetVoltageLighting())

# Register ExoLightCommand_SetVoltageLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.ExoLightCommand_SetVoltageLighting_swigregister(ExoLightCommand_SetVoltageLighting)
class ULC2_DC_Mode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    maxMilliAmpsDCMode = property(_HC_API_PythonPackage.ULC2_DC_Mode_maxMilliAmpsDCMode_get, _HC_API_PythonPackage.ULC2_DC_Mode_maxMilliAmpsDCMode_set, doc=r"""
    <summary>
    mac milliamps allowed to drive in DC mode.
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ULC2_DC_Mode_swiginit(self, _HC_API_PythonPackage.new_ULC2_DC_Mode())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ULC2_DC_Mode

# Register ULC2_DC_Mode in _HC_API_PythonPackage:
_HC_API_PythonPackage.ULC2_DC_Mode_swigregister(ULC2_DC_Mode)
class ULC2_STROBE_Mode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    strobeMilliAmpsLimit = property(_HC_API_PythonPackage.ULC2_STROBE_Mode_strobeMilliAmpsLimit_get, _HC_API_PythonPackage.ULC2_STROBE_Mode_strobeMilliAmpsLimit_set, doc=r"""
    <summary>
    strobe mode
    <summary>
    """)
    strobePulseWidthMaxLimitMicroSec = property(_HC_API_PythonPackage.ULC2_STROBE_Mode_strobePulseWidthMaxLimitMicroSec_get, _HC_API_PythonPackage.ULC2_STROBE_Mode_strobePulseWidthMaxLimitMicroSec_set, doc=r"""
    <summary>
    strobe mode
    <summary>
    """)
    strobeTriggerPeriodLimitMicroSec = property(_HC_API_PythonPackage.ULC2_STROBE_Mode_strobeTriggerPeriodLimitMicroSec_get, _HC_API_PythonPackage.ULC2_STROBE_Mode_strobeTriggerPeriodLimitMicroSec_set, doc=r"""
    <summary>
    strobe mode
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ULC2_STROBE_Mode_swiginit(self, _HC_API_PythonPackage.new_ULC2_STROBE_Mode())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ULC2_STROBE_Mode

# Register ULC2_STROBE_Mode in _HC_API_PythonPackage:
_HC_API_PythonPackage.ULC2_STROBE_Mode_swigregister(ULC2_STROBE_Mode)
class ULC2_VOLTAGE_Mode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    voltagelimitVolts = property(_HC_API_PythonPackage.ULC2_VOLTAGE_Mode_voltagelimitVolts_get, _HC_API_PythonPackage.ULC2_VOLTAGE_Mode_voltagelimitVolts_set, doc=r"""
    <summary>
    strobe mode
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ULC2_VOLTAGE_Mode_swiginit(self, _HC_API_PythonPackage.new_ULC2_VOLTAGE_Mode())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ULC2_VOLTAGE_Mode

# Register ULC2_VOLTAGE_Mode in _HC_API_PythonPackage:
_HC_API_PythonPackage.ULC2_VOLTAGE_Mode_swigregister(ULC2_VOLTAGE_Mode)
class ExoLight2DeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the ExoLight2 device.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ExoLight2DeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ExoLight2DeviceInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ExoLight2DeviceInfo
    channel = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_channel_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_channel_set, doc=r"""
    <summary>
    Channel as attached to the Metaphase ULC2 controller (1 or 2)
    <summary>
    """)
    driveMode = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_driveMode_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_driveMode_set, doc=r"""
    <summary>
    Drive Control Mode
    <summary>
    """)
    triggerControlsDC = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_triggerControlsDC_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_triggerControlsDC_set, doc=r"""
    <summary>

    <summary>
    """)
    triggerPolarity = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_triggerPolarity_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_triggerPolarity_set, doc=r"""
    <summary>
     Rising Edge (true) or Falling Edge (false)
    <summary>
    """)
    triggerType = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_triggerType_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_triggerType_set, doc=r"""
    <summary>
    Trigger type internal external.
    <summary>
    """)
    outputEnabled = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_outputEnabled_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_outputEnabled_set, doc=r"""
    <summary>
    Enable output to LED
    <summary>
    """)
    modeDCSettings = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_modeDCSettings_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_modeDCSettings_set)
    modeStrobeSettings = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_modeStrobeSettings_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_modeStrobeSettings_set)
    modeVoltageSettings = property(_HC_API_PythonPackage.ExoLight2DeviceInfo_modeVoltageSettings_get, _HC_API_PythonPackage.ExoLight2DeviceInfo_modeVoltageSettings_set)

    def __init__(self):
        _HC_API_PythonPackage.ExoLight2DeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ExoLight2DeviceInfo())

# Register ExoLight2DeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.ExoLight2DeviceInfo_swigregister(ExoLight2DeviceInfo)
class ULC2Controller(HardwareDeviceController):
    r"""
    <summary>
    base class controller for ULC2
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ULC2Controller_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ULC2Controller_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ULC2Controller
    ipAddress = property(_HC_API_PythonPackage.ULC2Controller_ipAddress_get, _HC_API_PythonPackage.ULC2Controller_ipAddress_set)
    localUdpPort = property(_HC_API_PythonPackage.ULC2Controller_localUdpPort_get, _HC_API_PythonPackage.ULC2Controller_localUdpPort_set)

    def __init__(self):
        _HC_API_PythonPackage.ULC2Controller_swiginit(self, _HC_API_PythonPackage.new_ULC2Controller())

# Register ULC2Controller in _HC_API_PythonPackage:
_HC_API_PythonPackage.ULC2Controller_swigregister(ULC2Controller)
class LedLightBoxCommand_Lighting(DeviceCommandPackage):
    r"""
    <summary>
    Command to set the lighting of a led light box.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxCommand_Lighting

    def cloneFrom(self, other):
        return _HC_API_PythonPackage.LedLightBoxCommand_Lighting_cloneFrom(self, other)
    dimmerIntensityPercent = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_dimmerIntensityPercent_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_dimmerIntensityPercent_set)
    colorTemperaturePerc = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_colorTemperaturePerc_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_colorTemperaturePerc_set)
    highLowSetting = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_highLowSetting_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_highLowSetting_set)
    flickerFrequencyHz = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerFrequencyHz_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerFrequencyHz_set)
    flickerDutyCyclePercent = property(_HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerDutyCyclePercent_get, _HC_API_PythonPackage.LedLightBoxCommand_Lighting_flickerDutyCyclePercent_set)

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxCommand_Lighting_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxCommand_Lighting())

# Register LedLightBoxCommand_Lighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxCommand_Lighting_swigregister(LedLightBoxCommand_Lighting)
LedLightBox_NALPCODE = cvar.LedLightBox_NALPCODE

class LedLightPanelCommand_SetLighting(LedLightBoxCommand_Lighting):
    r"""
    <summary>
    Command to set the lighting of a led light panel.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightPanelCommand_SetLighting

    def __init__(self):
        _HC_API_PythonPackage.LedLightPanelCommand_SetLighting_swiginit(self, _HC_API_PythonPackage.new_LedLightPanelCommand_SetLighting())

# Register LedLightPanelCommand_SetLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightPanelCommand_SetLighting_swigregister(LedLightPanelCommand_SetLighting)
class LedLightBoxDeviceInfo(DeviceInfo):
    r"""
    <summary>
    https://www.imatest.com/product/imatest-led-lightbox/
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxDeviceInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDeviceInfo
    maxDimmerIntegerHigh = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerHigh_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerHigh_set)
    maxDimmerIntegerLow = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerLow_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_maxDimmerIntegerLow_set)
    highLowCapable = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_highLowCapable_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_highLowCapable_set)
    mixedCapable = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_mixedCapable_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_mixedCapable_set)
    isPanel = property(_HC_API_PythonPackage.LedLightBoxDeviceInfo_isPanel_get, _HC_API_PythonPackage.LedLightBoxDeviceInfo_isPanel_set)

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDeviceInfo())

# Register LedLightBoxDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxDeviceInfo_swigregister(LedLightBoxDeviceInfo)
class LedLightBoxDevice_Standard_LED_Box_Single_Info(LedLightBoxDeviceInfo):
    r"""
    <summary>
    device info for Standard_LED_Box_Single
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_Standard_LED_Box_Single_Info

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_Standard_LED_Box_Single_Info())

    @staticmethod
    def friendlyName():
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_friendlyName()

# Register LedLightBoxDevice_Standard_LED_Box_Single_Info in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Single_Info_swigregister(LedLightBoxDevice_Standard_LED_Box_Single_Info)
class LedLightBoxDevice_Standard_LED_Box_Mixed_Info(LedLightBoxDeviceInfo):
    r"""
    <summary>
    device info for Standard_LED_Box_Mixed
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_Standard_LED_Box_Mixed_Info

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_Standard_LED_Box_Mixed_Info())

    @staticmethod
    def friendlyName():
        return _HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_friendlyName()

# Register LedLightBoxDevice_Standard_LED_Box_Mixed_Info in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxDevice_Standard_LED_Box_Mixed_Info_swigregister(LedLightBoxDevice_Standard_LED_Box_Mixed_Info)
class LedLightBoxDevice_High_LUX_LED_Box_Single_Info(LedLightBoxDeviceInfo):
    r"""
    <summary>
    device info for High_LUX_LED_Box_Single
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_High_LUX_LED_Box_Single_Info

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_High_LUX_LED_Box_Single_Info())

    @staticmethod
    def friendlyName():
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_friendlyName()

# Register LedLightBoxDevice_High_LUX_LED_Box_Single_Info in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Single_Info_swigregister(LedLightBoxDevice_High_LUX_LED_Box_Single_Info)
class LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info(LedLightBoxDeviceInfo):
    r"""
    <summary>
    device info for High_LUX_LED_Box_Mixed
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info())

    @staticmethod
    def friendlyName():
        return _HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_friendlyName()

# Register LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info_swigregister(LedLightBoxDevice_High_LUX_LED_Box_Mixed_Info)
class LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info(LedLightBoxDeviceInfo):
    r"""
    <summary>
    device info for Ultra_High_Illumination_Flickering
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info())

    @staticmethod
    def friendlyName():
        return _HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_friendlyName()

# Register LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info_swigregister(LedLightBoxDevice_Ultra_High_Illumination_Flickering_Info)
class LedLightBoxControllerBase(HardwareDeviceController):
    r"""
    <summary>
    base class for led light box controllers
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxControllerBase_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxControllerBase_className(self)

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxControllerBase_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxControllerBase())
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxControllerBase

# Register LedLightBoxControllerBase in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxControllerBase_swigregister(LedLightBoxControllerBase)
class LedLightBoxController(LedLightBoxControllerBase):
    r"""
    <summary>
    controller for LedLightBox
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightBoxController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightBoxController_className(self)

    def __init__(self):
        _HC_API_PythonPackage.LedLightBoxController_swiginit(self, _HC_API_PythonPackage.new_LedLightBoxController())
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightBoxController

# Register LedLightBoxController in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightBoxController_swigregister(LedLightBoxController)
class LedLightPanel_Single_Info(LedLightBoxDeviceInfo):
    r"""
    <summary>
    https://www.imatest.com/wp-content/uploads/2019/04/Imatest-LED-Light-Panel_Info-Sheet.pdf
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LedLightPanel_Single_Info_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LedLightPanel_Single_Info_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LedLightPanel_Single_Info_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LedLightPanel_Single_Info

    def __init__(self):
        _HC_API_PythonPackage.LedLightPanel_Single_Info_swiginit(self, _HC_API_PythonPackage.new_LedLightPanel_Single_Info())

    @staticmethod
    def friendlyName():
        return _HC_API_PythonPackage.LedLightPanel_Single_Info_friendlyName()

# Register LedLightPanel_Single_Info in _HC_API_PythonPackage:
_HC_API_PythonPackage.LedLightPanel_Single_Info_swigregister(LedLightPanel_Single_Info)
IsoLightPuck_LEDPatterns_Continuous_Red = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Red
IsoLightPuck_LEDPatterns_Continuous_Yellow = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Yellow
IsoLightPuck_LEDPatterns_Continuous_Green = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Green
IsoLightPuck_LEDPatterns_Continuous_Blue = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Blue
IsoLightPuck_LEDPatterns_Continuous_Magenta = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Continuous_Magenta
IsoLightPuck_LEDPatterns_Flashing_Red = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Red
IsoLightPuck_LEDPatterns_Flashing_Yellow = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Yellow
IsoLightPuck_LEDPatterns_Flashing_Green = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Green
IsoLightPuck_LEDPatterns_Flashing_Blue = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Blue
IsoLightPuck_LEDPatterns_Flashing_Magenta = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Flashing_Magenta
IsoLightPuck_LEDPatterns_Spin_Red = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Red
IsoLightPuck_LEDPatterns_Spin_Yellow = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Yellow
IsoLightPuck_LEDPatterns_Spin_Green = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Green
IsoLightPuck_LEDPatterns_Spin_Blue = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Blue
IsoLightPuck_LEDPatterns_Spin_Magenta = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_Spin_Magenta
IsoLightPuck_LEDPatterns_RainbowCycle = _HC_API_PythonPackage.IsoLightPuck_LEDPatterns_RainbowCycle
class IsolightPuckCommand_Update(DeviceCommandPackage):
    r"""
    <summary>
    Command to update the lighting and take light sensor reading from the isolight puck.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.IsolightPuckCommand_Update_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.IsolightPuckCommand_Update_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.IsolightPuckCommand_Update_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckCommand_Update
    ledPattern = property(_HC_API_PythonPackage.IsolightPuckCommand_Update_ledPattern_get, _HC_API_PythonPackage.IsolightPuckCommand_Update_ledPattern_set, doc=r"""
    <summary>
    LED pattern
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.IsolightPuckCommand_Update_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckCommand_Update())

# Register IsolightPuckCommand_Update in _HC_API_PythonPackage:
_HC_API_PythonPackage.IsolightPuckCommand_Update_swigregister(IsolightPuckCommand_Update)
class IsolightPuckUpdateStateInfo(CommandStateInfo):
    r"""
    <summary>
    State Info providing readings from the isolight puck sensor.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_className(self)
    sensor_GRXYZ_X = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_X_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_X_set, doc=r"""
    <summary>
    GRXYZ values
    <summary>
    """)
    sensor_GRXYZ_Y = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Y_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Y_set)
    sensor_GRXYZ_Z = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Z_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_GRXYZ_Z_set)
    sensor_x_normalized = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_x_normalized_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_x_normalized_set, doc=r"""
    <summary>
    normalized x,y,z values
    <summary>
    """)
    sensor_y_normalized = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_y_normalized_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_y_normalized_set)
    sensor_z_normalized = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_z_normalized_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_z_normalized_set)
    sensor_u_prime = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_u_prime_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_u_prime_set, doc=r"""
    <summary>
    Yu'v' color space
    <summary>
    """)
    sensor_v_prime = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_v_prime_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_v_prime_set)
    sensor_cct = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_cct_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_cct_set, doc=r"""
    <summary>
    correlated color temperature (K)
    <summary>
    """)
    sensor_lightlevel = property(_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_lightlevel_get, _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_sensor_lightlevel_set, doc=r"""
    <summary>
    light level in lux
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.IsolightPuckUpdateStateInfo_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckUpdateStateInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckUpdateStateInfo

# Register IsolightPuckUpdateStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.IsolightPuckUpdateStateInfo_swigregister(IsolightPuckUpdateStateInfo)
class IsolightPuckCommandStatus(CommandStatus):
    r"""
    <summary>
    Command status for the isolight puck.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.IsolightPuckCommandStatus_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.IsolightPuckCommandStatus_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckCommandStatus

    def stateInfo(self):
        return _HC_API_PythonPackage.IsolightPuckCommandStatus_stateInfo(self)

    def __init__(self):
        _HC_API_PythonPackage.IsolightPuckCommandStatus_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckCommandStatus())

# Register IsolightPuckCommandStatus in _HC_API_PythonPackage:
_HC_API_PythonPackage.IsolightPuckCommandStatus_swigregister(IsolightPuckCommandStatus)
class IsolightPuckDeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the isolight puck.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.IsolightPuckDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.IsolightPuckDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.IsolightPuckDeviceInfo_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckDeviceInfo
    port = property(_HC_API_PythonPackage.IsolightPuckDeviceInfo_port_get, _HC_API_PythonPackage.IsolightPuckDeviceInfo_port_set, doc=r""" Sereal Port Associated with the puck""")
    updateRateMS = property(_HC_API_PythonPackage.IsolightPuckDeviceInfo_updateRateMS_get, _HC_API_PythonPackage.IsolightPuckDeviceInfo_updateRateMS_set, doc=r"""
    <summary>
    suggested update rate of the internal sensor in milliseconds,  sensor may increase this in order to take accurate readings.
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.IsolightPuckDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckDeviceInfo())

# Register IsolightPuckDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.IsolightPuckDeviceInfo_swigregister(IsolightPuckDeviceInfo)
class IsolightPuckController(HardwareDeviceController):
    r"""
    <summary>
    Controller for the isolight puck.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.IsolightPuckController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.IsolightPuckController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_IsolightPuckController

    def __init__(self):
        _HC_API_PythonPackage.IsolightPuckController_swiginit(self, _HC_API_PythonPackage.new_IsolightPuckController())

# Register IsolightPuckController in _HC_API_PythonPackage:
_HC_API_PythonPackage.IsolightPuckController_swigregister(IsolightPuckController)
class SpectralSensor_SpecDataInfo(object):
    r"""
    <summary>
    Data Info for the Spectral Sensor
    <summary>
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iType = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iType_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iType_set)
    iVer = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iVer_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_iVer_set)
    Mark = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Mark_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Mark_set)
    fLx = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fLx_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fLx_set)
    fEfc = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fEfc_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fEfc_set)
    cct = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_cct_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_cct_set)
    duv = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_duv_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_duv_set)
    x = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_x_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_x_set)
    y = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_y_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_y_set)
    u = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u_set)
    v = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v_set)
    u2 = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u2_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_u2_set)
    v2 = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v2_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_v2_set)
    Ra = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ra_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ra_set)
    Ri = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ri_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Ri_set)
    fSP = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fSP_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fSP_set)
    DominantWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_DominantWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_DominantWave_set)
    Purity = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Purity_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Purity_set)
    HlafWidth = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_HlafWidth_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_HlafWidth_set)
    PeakWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_PeakWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_PeakWave_set)
    CentreWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentreWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentreWave_set)
    CentroidWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentroidWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_CentroidWave_set)
    fRraito = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fRraito_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fRraito_set)
    fGraito = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fGraito_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fGraito_set)
    fBraito = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fBraito_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_fBraito_set)
    IntegTime0 = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_IntegTime0_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_IntegTime0_set)
    VPeak = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VPeak_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VPeak_set)
    VDark = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDark_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDark_set)
    VDarkDAC = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDarkDAC_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_VDarkDAC_set)
    TestDate = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestDate_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestDate_set)
    TestTime = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestTime_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_TestTime_set)
    Spect1nmData = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Spect1nmData_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_Spect1nmData_set)
    StartTestWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWave_set)
    EndTestWave = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWave_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWave_set)
    StartTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_StartTestWaveIdx_set)
    EndTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_EndTestWaveIdx_set)

    def __init__(self):
        _HC_API_PythonPackage.SpectralSensor_SpecDataInfo_swiginit(self, _HC_API_PythonPackage.new_SpectralSensor_SpecDataInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensor_SpecDataInfo

# Register SpectralSensor_SpecDataInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.SpectralSensor_SpecDataInfo_swigregister(SpectralSensor_SpecDataInfo)
SpectralSensor_NALPCODE = cvar.SpectralSensor_NALPCODE

class SpectralSensorCommand_Update(DeviceCommandPackage):
    r"""
    <summary>
    Command to update the lighting and take light sensor reading from the isolight puck.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.SpectralSensorCommand_Update_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.SpectralSensorCommand_Update_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.SpectralSensorCommand_Update_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorCommand_Update
    integralTime_US = property(_HC_API_PythonPackage.SpectralSensorCommand_Update_integralTime_US_get, _HC_API_PythonPackage.SpectralSensorCommand_Update_integralTime_US_set, doc=r"""
    <summary>
    Time in microseconds the device should integrate over for each end-result sample
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.SpectralSensorCommand_Update_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorCommand_Update())

# Register SpectralSensorCommand_Update in _HC_API_PythonPackage:
_HC_API_PythonPackage.SpectralSensorCommand_Update_swigregister(SpectralSensorCommand_Update)
class SpectralSensorUpdateStateInfo(CommandStateInfo):
    r"""
    <summary>
    State Info providing readings from the SpectralSensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_className(self)
    iType = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iType_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iType_set, doc=r"""Spectrograph/lighting data""")
    iVer = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iVer_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_iVer_set)
    Mark = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Mark_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Mark_set)
    fLx = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fLx_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fLx_set)
    fEfc = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fEfc_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fEfc_set)
    cct = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_cct_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_cct_set)
    duv = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_duv_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_duv_set)
    x = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_x_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_x_set)
    y = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_y_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_y_set)
    u = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u_set)
    v = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v_set)
    u2 = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u2_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_u2_set)
    v2 = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v2_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_v2_set)
    Ra = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ra_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ra_set)
    Ri = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ri_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Ri_set)
    fSP = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fSP_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fSP_set)
    DominantWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_DominantWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_DominantWave_set)
    Purity = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Purity_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Purity_set)
    HlafWidth = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_HlafWidth_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_HlafWidth_set)
    PeakWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_PeakWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_PeakWave_set)
    CentreWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentreWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentreWave_set)
    CentroidWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentroidWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_CentroidWave_set)
    fRraito = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fRraito_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fRraito_set)
    fGraito = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fGraito_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fGraito_set)
    fBraito = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fBraito_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_fBraito_set)
    IntegTime0 = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_IntegTime0_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_IntegTime0_set)
    VPeak = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VPeak_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VPeak_set)
    VDark = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDark_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDark_set)
    VDarkDAC = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDarkDAC_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_VDarkDAC_set)
    TestDate = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestDate_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestDate_set)
    TestTime = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestTime_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_TestTime_set)
    Spect1nmData = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Spect1nmData_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_Spect1nmData_set)
    StartTestWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWave_set)
    EndTestWave = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWave_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWave_set)
    StartTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_StartTestWaveIdx_set)
    EndTestWaveIdx = property(_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWaveIdx_get, _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_EndTestWaveIdx_set)

    def __init__(self):
        _HC_API_PythonPackage.SpectralSensorUpdateStateInfo_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorUpdateStateInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorUpdateStateInfo

# Register SpectralSensorUpdateStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.SpectralSensorUpdateStateInfo_swigregister(SpectralSensorUpdateStateInfo)
class SpectralSensorCommandStatus(CommandStatus):
    r"""
    <summary>
    Command Status for the Spectral Sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.SpectralSensorCommandStatus_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.SpectralSensorCommandStatus_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorCommandStatus

    def stateInfo(self):
        return _HC_API_PythonPackage.SpectralSensorCommandStatus_stateInfo(self)

    def __init__(self):
        _HC_API_PythonPackage.SpectralSensorCommandStatus_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorCommandStatus())

# Register SpectralSensorCommandStatus in _HC_API_PythonPackage:
_HC_API_PythonPackage.SpectralSensorCommandStatus_swigregister(SpectralSensorCommandStatus)
class SpectralSensorDeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the Spectral Sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.SpectralSensorDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.SpectralSensorDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.SpectralSensorDeviceInfo_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorDeviceInfo

    def __init__(self):
        _HC_API_PythonPackage.SpectralSensorDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorDeviceInfo())

# Register SpectralSensorDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.SpectralSensorDeviceInfo_swigregister(SpectralSensorDeviceInfo)
class SpectralSensorController(HardwareDeviceController):
    r"""
    <summary>
    Controller for the Spectral Sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.SpectralSensorController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.SpectralSensorController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_SpectralSensorController

    def __init__(self):
        _HC_API_PythonPackage.SpectralSensorController_swiginit(self, _HC_API_PythonPackage.new_SpectralSensorController())

# Register SpectralSensorController in _HC_API_PythonPackage:
_HC_API_PythonPackage.SpectralSensorController_swigregister(SpectralSensorController)
class LowLightSensor_DataInfo(object):
    r"""
    <summary>
    Data Info for the Low Light Sensor
    <summary>
    """

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

    def __init__(self):
        _HC_API_PythonPackage.LowLightSensor_DataInfo_swiginit(self, _HC_API_PythonPackage.new_LowLightSensor_DataInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensor_DataInfo

# Register LowLightSensor_DataInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LowLightSensor_DataInfo_swigregister(LowLightSensor_DataInfo)
LowLightSensor_NALPCODE = cvar.LowLightSensor_NALPCODE

class LowLightSensorCommand_Update(DeviceCommandPackage):
    r"""
    <summary>
    Command to update the lighting and take light sensor reading
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.LowLightSensorCommand_Update_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LowLightSensorCommand_Update_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LowLightSensorCommand_Update_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorCommand_Update

    def __init__(self):
        _HC_API_PythonPackage.LowLightSensorCommand_Update_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorCommand_Update())

# Register LowLightSensorCommand_Update in _HC_API_PythonPackage:
_HC_API_PythonPackage.LowLightSensorCommand_Update_swigregister(LowLightSensorCommand_Update)
class LowLightSensorUpdateStateInfo(CommandStateInfo):
    r"""
    <summary>
    State Info providing readings from the low light sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_className(self)
    lx = property(_HC_API_PythonPackage.LowLightSensorUpdateStateInfo_lx_get, _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_lx_set)

    def __init__(self):
        _HC_API_PythonPackage.LowLightSensorUpdateStateInfo_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorUpdateStateInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorUpdateStateInfo

# Register LowLightSensorUpdateStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LowLightSensorUpdateStateInfo_swigregister(LowLightSensorUpdateStateInfo)
class LowLightSensorCommandStatus(CommandStatus):
    r"""
    <summary>
    Command Status for the Low Light Sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LowLightSensorCommandStatus_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LowLightSensorCommandStatus_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorCommandStatus

    def stateInfo(self):
        return _HC_API_PythonPackage.LowLightSensorCommandStatus_stateInfo(self)

    def __init__(self):
        _HC_API_PythonPackage.LowLightSensorCommandStatus_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorCommandStatus())

# Register LowLightSensorCommandStatus in _HC_API_PythonPackage:
_HC_API_PythonPackage.LowLightSensorCommandStatus_swigregister(LowLightSensorCommandStatus)
class LowLightSensorDeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the Low Light Sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LowLightSensorDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LowLightSensorDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LowLightSensorDeviceInfo_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorDeviceInfo

    def __init__(self):
        _HC_API_PythonPackage.LowLightSensorDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorDeviceInfo())

# Register LowLightSensorDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LowLightSensorDeviceInfo_swigregister(LowLightSensorDeviceInfo)
class LowLightSensorController(HardwareDeviceController):
    r"""
    <summary>
    Controller for the Low Light Sensor
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LowLightSensorController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LowLightSensorController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LowLightSensorController

    def __init__(self):
        _HC_API_PythonPackage.LowLightSensorController_swiginit(self, _HC_API_PythonPackage.new_LowLightSensorController())

# Register LowLightSensorController in _HC_API_PythonPackage:
_HC_API_PythonPackage.LowLightSensorController_swigregister(LowLightSensorController)
class ZaberAxisInfo(PhysicalAxisControlInfo):
    r"""
    <summary>
    Axis Info for attaching to a Zaber Device
    <summary>
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    alias = property(_HC_API_PythonPackage.ZaberAxisInfo_alias_get, _HC_API_PythonPackage.ZaberAxisInfo_alias_set)
    apiAxisIdx = property(_HC_API_PythonPackage.ZaberAxisInfo_apiAxisIdx_get, _HC_API_PythonPackage.ZaberAxisInfo_apiAxisIdx_set)

    def __init__(self):
        _HC_API_PythonPackage.ZaberAxisInfo_swiginit(self, _HC_API_PythonPackage.new_ZaberAxisInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ZaberAxisInfo

# Register ZaberAxisInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.ZaberAxisInfo_swigregister(ZaberAxisInfo)
class ZaberDeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for a single Zaber device.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ZaberDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ZaberDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.ZaberDeviceInfo_addCommand(self, package)

    def __init__(self):
        _HC_API_PythonPackage.ZaberDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ZaberDeviceInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ZaberDeviceInfo

    def AddAxisInfo(self, axis):
        return _HC_API_PythonPackage.ZaberDeviceInfo_AddAxisInfo(self, axis)

    def initializeCommand(self, commandPacakge):
        return _HC_API_PythonPackage.ZaberDeviceInfo_initializeCommand(self, commandPacakge)
    zaberDeviceAddress = property(_HC_API_PythonPackage.ZaberDeviceInfo_zaberDeviceAddress_get, _HC_API_PythonPackage.ZaberDeviceInfo_zaberDeviceAddress_set)
    internals = property(_HC_API_PythonPackage.ZaberDeviceInfo_internals_get, _HC_API_PythonPackage.ZaberDeviceInfo_internals_set)
    motionSim = property(_HC_API_PythonPackage.ZaberDeviceInfo_motionSim_get, _HC_API_PythonPackage.ZaberDeviceInfo_motionSim_set)

# Register ZaberDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.ZaberDeviceInfo_swigregister(ZaberDeviceInfo)
class ZaberCommandSetAxisMovement(MovementCommandPackage):
    r"""
    <summary>
    command to set axis movement on a zaber device
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ZaberCommandSetAxisMovement_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ZaberCommandSetAxisMovement_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ZaberCommandSetAxisMovement_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandSetAxisMovement
    doNativeHome = property(_HC_API_PythonPackage.ZaberCommandSetAxisMovement_doNativeHome_get, _HC_API_PythonPackage.ZaberCommandSetAxisMovement_doNativeHome_set, doc=r"""
    <summary>
    Ignores all other parameters and calls home() on the zaber device.
    <summary>
    """)
    zaberAxisId = property(_HC_API_PythonPackage.ZaberCommandSetAxisMovement_zaberAxisId_get, _HC_API_PythonPackage.ZaberCommandSetAxisMovement_zaberAxisId_set)

    def __init__(self):
        _HC_API_PythonPackage.ZaberCommandSetAxisMovement_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandSetAxisMovement())

# Register ZaberCommandSetAxisMovement in _HC_API_PythonPackage:
_HC_API_PythonPackage.ZaberCommandSetAxisMovement_swigregister(ZaberCommandSetAxisMovement)

def As_ZaberCommandSetAxisMovement(package):
    return _HC_API_PythonPackage.As_ZaberCommandSetAxisMovement(package)
class ZaberCommandStorageKeyStateInfo(CommandStateInfo):
    r"""
    <summary>
    state info for storage keystate of a zaber device.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_className(self)
    value = property(_HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_value_get, _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_value_set)

    def __init__(self):
        _HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandStorageKeyStateInfo())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandStorageKeyStateInfo

# Register ZaberCommandStorageKeyStateInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.ZaberCommandStorageKeyStateInfo_swigregister(ZaberCommandStorageKeyStateInfo)
class ZaberCommandSetStorageKey(DeviceCommandPackage):
    r"""
    <summary>
    command to set the storage key / value on a zaber device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ZaberCommandSetStorageKey_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ZaberCommandSetStorageKey_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ZaberCommandSetStorageKey_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandSetStorageKey
    key = property(_HC_API_PythonPackage.ZaberCommandSetStorageKey_key_get, _HC_API_PythonPackage.ZaberCommandSetStorageKey_key_set, doc=r"""
    <summary>
    Zaber Storage Key
    <summary>
    """)
    number = property(_HC_API_PythonPackage.ZaberCommandSetStorageKey_number_get, _HC_API_PythonPackage.ZaberCommandSetStorageKey_number_set)

    def __init__(self):
        _HC_API_PythonPackage.ZaberCommandSetStorageKey_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandSetStorageKey())

# Register ZaberCommandSetStorageKey in _HC_API_PythonPackage:
_HC_API_PythonPackage.ZaberCommandSetStorageKey_swigregister(ZaberCommandSetStorageKey)

def As_ZaberCommandSetStorageKey(package):
    return _HC_API_PythonPackage.As_ZaberCommandSetStorageKey(package)
class ZaberCommandGetStorageKey(DeviceCommandPackage):
    r"""
    <summary>
    command to get the storage key / value on a zaber device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ZaberCommandGetStorageKey_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ZaberCommandGetStorageKey_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ZaberCommandGetStorageKey_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ZaberCommandGetStorageKey
    key = property(_HC_API_PythonPackage.ZaberCommandGetStorageKey_key_get, _HC_API_PythonPackage.ZaberCommandGetStorageKey_key_set, doc=r"""
    <summary>
    Zaber Storage Key
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ZaberCommandGetStorageKey_swiginit(self, _HC_API_PythonPackage.new_ZaberCommandGetStorageKey())

# Register ZaberCommandGetStorageKey in _HC_API_PythonPackage:
_HC_API_PythonPackage.ZaberCommandGetStorageKey_swigregister(ZaberCommandGetStorageKey)

def As_ZaberCommandGetStorageKey(package):
    return _HC_API_PythonPackage.As_ZaberCommandGetStorageKey(package)
class zaberController(HardwareDeviceController):
    r"""
    <summary>
    controller for Zaber devices
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.zaberController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.zaberController_className(self)

    def __init__(self):
        _HC_API_PythonPackage.zaberController_swiginit(self, _HC_API_PythonPackage.new_zaberController())
    __swig_destroy__ = _HC_API_PythonPackage.delete_zaberController

# Register zaberController in _HC_API_PythonPackage:
_HC_API_PythonPackage.zaberController_swigregister(zaberController)

def zaber_To_HomeSpace(zaber):
    r"""
    <summary>
    convert zaber axis positions to homespace coordinates.
    <summary>
    <param name="zaber"><param>
    <returns><returns>
    """
    return _HC_API_PythonPackage.zaber_To_HomeSpace(zaber)

def homeSpace_To_Zaber(home):
    r"""
    <summary>

    <summary>
    <param name="home"><param>
    <returns><returns>
    """
    return _HC_API_PythonPackage.homeSpace_To_Zaber(home)
class CompositeCommandStatusSet(CommandStatusControlMethods):
    r""" base class for giving access to composite command status sets.  and functions to manage groups of commands etc."""

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

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CompositeCommandStatusSet_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_className(self)

    def runFull(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_runFull(self)

    def runASync(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_runASync(self)

    def initialize(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_initialize(self)

    def updateoverride(self, stepped=False):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_updateoverride(self, stepped)

    def waitUpdateReady(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_waitUpdateReady(self)

    def waitUpdateReadyOrFinished(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_waitUpdateReadyOrFinished(self)

    def waitFinished(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_waitFinished(self)

    def stop(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_stop(self)

    def isBusy(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_isBusy(self)

    def isFinished(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_isFinished(self)

    def isCancelled(self):
        return _HC_API_PythonPackage.CompositeCommandStatusSet_isCancelled(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_CompositeCommandStatusSet

# Register CompositeCommandStatusSet in _HC_API_PythonPackage:
_HC_API_PythonPackage.CompositeCommandStatusSet_swigregister(CompositeCommandStatusSet)
class CompositeFrameBase(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CompositeFrameBase_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CompositeFrameBase_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_CompositeFrameBase

    def __init__(self):
        _HC_API_PythonPackage.CompositeFrameBase_swiginit(self, _HC_API_PythonPackage.new_CompositeFrameBase())
    system = property(_HC_API_PythonPackage.CompositeFrameBase_system_get, _HC_API_PythonPackage.CompositeFrameBase_system_set)

# Register CompositeFrameBase in _HC_API_PythonPackage:
_HC_API_PythonPackage.CompositeFrameBase_swigregister(CompositeFrameBase)
class BTSFramingCommandStatusSet(CompositeCommandStatusSet):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.BTSFramingCommandStatusSet_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.BTSFramingCommandStatusSet_className(self)
    xAxis = property(_HC_API_PythonPackage.BTSFramingCommandStatusSet_xAxis_get, _HC_API_PythonPackage.BTSFramingCommandStatusSet_xAxis_set)
    zAxis = property(_HC_API_PythonPackage.BTSFramingCommandStatusSet_zAxis_get, _HC_API_PythonPackage.BTSFramingCommandStatusSet_zAxis_set)
    __swig_destroy__ = _HC_API_PythonPackage.delete_BTSFramingCommandStatusSet

# Register BTSFramingCommandStatusSet in _HC_API_PythonPackage:
_HC_API_PythonPackage.BTSFramingCommandStatusSet_swigregister(BTSFramingCommandStatusSet)
class BTSFraming(CompositeFrameBase):
    r"""
    <summary>
    BTSFraming class, contains methods for control of BTS frames.
    all dimension Units are in millimeters

    https://drive.google.com/file/d/1pRtOPzCtmoEOHzolEsyHNhHvKwgjnRsm/view?usp=drive_link

    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.BTSFraming_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.BTSFraming_className(self)
    zaberPort = property(_HC_API_PythonPackage.BTSFraming_zaberPort_get, _HC_API_PythonPackage.BTSFraming_zaberPort_set, doc=r"""
    <summary>
    Serial Port for zaber (ex "COM4")
    Set Before initialization.
    <summary>
    """)
    ChartCenterHome_CameraCenterFrame = property(_HC_API_PythonPackage.BTSFraming_ChartCenterHome_CameraCenterFrame_get, _HC_API_PythonPackage.BTSFraming_ChartCenterHome_CameraCenterFrame_set, doc=r"""
    <summary>
    Chart center home position in the cameracenter frame.
    Units: millimeters
    <summary>
    """)
    calibrationOffset = property(_HC_API_PythonPackage.BTSFraming_calibrationOffset_get, _HC_API_PythonPackage.BTSFraming_calibrationOffset_set, doc=r"""
    <summary>
    Calibration offset (can be obtained by calling doCalibrationAndValidation)
    <summary>
    <param name="calibration"><param>
    """)
    chartCenterFrame_CameraCenterFrame = property(_HC_API_PythonPackage.BTSFraming_chartCenterFrame_CameraCenterFrame_get, _HC_API_PythonPackage.BTSFraming_chartCenterFrame_CameraCenterFrame_set, doc=r"""
    <summary>
    Current relative location of the chartCenter to the CameraCenter
    <summary>
    """)

    def initialize(self, system):
        r"""
        initialize the frame using the given config.
        :param config:
        """
        return _HC_API_PythonPackage.BTSFraming_initialize(self, system)

    def Home(self):
        r"""
        Command targetMountFrame to go to TargetMountHome position
        use if axis' have been moved manually or without power to reset the BTSFrame.
        """
        return _HC_API_PythonPackage.BTSFraming_Home(self)

    def chartCenterFrame_Go_ChartCenterHomeFrame(self, homeSpace):
        r"""
        <summary>
        Command the chartCenterFrame to go somewhere relative to the chartCenterHomeFrame
        <summary>
        <param name="homeSpace"><param>
        """
        return _HC_API_PythonPackage.BTSFraming_chartCenterFrame_Go_ChartCenterHomeFrame(self, homeSpace)

    def chartCenterFrame_Go_CameraCenterFrame(self, cameraSpace):
        r"""
        <summary>
        Command the chartCenterFrame to move to a location relative to the CameraFrame
        <summary>
        """
        return _HC_API_PythonPackage.BTSFraming_chartCenterFrame_Go_CameraCenterFrame(self, cameraSpace)

    def doCalibrationAndValidation(self):
        r"""
        <summary>
        Do calibration and validation routine.  prompts the user for micrometer reading.  reports validation meaurements
        returns calibration offset for use later.
        <summary>
        <returns><returns>
        """
        return _HC_API_PythonPackage.BTSFraming_doCalibrationAndValidation(self)

    def homeFrame_To_cameraCenterFrame(self, homeSpace):
        r"""
        <summary>
        Transform vector in the homeFrame to cameraCenterFrame.
        <summary>
        <param name="homeSpace"><param>
        <returns><returns>
        """
        return _HC_API_PythonPackage.BTSFraming_homeFrame_To_cameraCenterFrame(self, homeSpace)

    def cameraCenterFrame_To_homeFrame(self, cameraSpace):
        r"""
        <summary>
        Transform vector from cameraCenterFrame to homeFrame
        <summary>
        <param name="cameraSpace"><param>
        <returns><returns>
        """
        return _HC_API_PythonPackage.BTSFraming_cameraCenterFrame_To_homeFrame(self, cameraSpace)
    stageVelocity = property(_HC_API_PythonPackage.BTSFraming_stageVelocity_get, _HC_API_PythonPackage.BTSFraming_stageVelocity_set, doc=r"""
    <summary>
    Velocity to command the stages to use.
    <summary>
    """)
    stageAcceleration = property(_HC_API_PythonPackage.BTSFraming_stageAcceleration_get, _HC_API_PythonPackage.BTSFraming_stageAcceleration_set, doc=r"""
    <summary>
    Acceleration to command the stages to use.
    <summary>
    """)

    def zaberCont(self):
        return _HC_API_PythonPackage.BTSFraming_zaberCont(self)

    def zaberDevice1(self):
        return _HC_API_PythonPackage.BTSFraming_zaberDevice1(self)

    def zaberDevice2(self):
        return _HC_API_PythonPackage.BTSFraming_zaberDevice2(self)

    def zaberDevice1Axis(self):
        return _HC_API_PythonPackage.BTSFraming_zaberDevice1Axis(self)

    def zaberDevice2Axis(self):
        return _HC_API_PythonPackage.BTSFraming_zaberDevice2Axis(self)

    def __init__(self):
        _HC_API_PythonPackage.BTSFraming_swiginit(self, _HC_API_PythonPackage.new_BTSFraming())
    __swig_destroy__ = _HC_API_PythonPackage.delete_BTSFraming

# Register BTSFraming in _HC_API_PythonPackage:
_HC_API_PythonPackage.BTSFraming_swigregister(BTSFraming)
class VCXFraming(CompositeFrameBase):
    r"""
    <summary>
    DEPRECIATED.
    VCX Framing class, contains methods for control of VCX frames.
    all dimension Units are in millimeters
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.VCXFraming_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.VCXFraming_className(self)
    chartCenter__MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_chartCenter__MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_chartCenter__MechanicalOriginFrame_set, doc=r"""
    <summary>
    chart center position Relative to mechanical base point.
    "Vector B"
    Units: millimeters
    <summary>
    """)
    home__MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_home__MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_home__MechanicalOriginFrame_set, doc=r"""
    <summary>
    Home position of table relative to mechanical base point.
    "Vector A"
    Units: millimeters
    <summary>
    """)
    camera_MountBaseFrame = property(_HC_API_PythonPackage.VCXFraming_camera_MountBaseFrame_get, _HC_API_PythonPackage.VCXFraming_camera_MountBaseFrame_set, doc=r"""
    <summary>
    Camera position relative to the MountBaseFrame.
    <summary>
    """)
    mountBase_MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_mountBase_MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_mountBase_MechanicalOriginFrame_set, doc=r""" current target mount position in the mechanical origin frame.""")
    mountBase_Omega_MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_mountBase_Omega_MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_mountBase_Omega_MechanicalOriginFrame_set, doc=r""" current rotation of MountBase in the mechanicalOrigin frame.""")
    camera_MechanicalOriginFrame = property(_HC_API_PythonPackage.VCXFraming_camera_MechanicalOriginFrame_get, _HC_API_PythonPackage.VCXFraming_camera_MechanicalOriginFrame_set, doc=r"""
    <summary>
    Current Camera position in mechanicalorigin Frame.
    <summary>
    """)
    camera_ChartCenterFrame = property(_HC_API_PythonPackage.VCXFraming_camera_ChartCenterFrame_get, _HC_API_PythonPackage.VCXFraming_camera_ChartCenterFrame_set, doc=r"""
    <summary>
    Current Camera Position in ChartCenter Frame.
    <summary>
    """)
    zaberPort = property(_HC_API_PythonPackage.VCXFraming_zaberPort_get, _HC_API_PythonPackage.VCXFraming_zaberPort_set, doc=r"""
    <summary>
    Serial Port for zaber (ex "COM4")
    <summary>
    """)
    liftingColumnPort = property(_HC_API_PythonPackage.VCXFraming_liftingColumnPort_get, _HC_API_PythonPackage.VCXFraming_liftingColumnPort_set, doc=r"""
    <summary>
    Serial Port for Lifting Column. (ex "COM5")
    <summary>
    """)

    def initialize(self, system):
        return _HC_API_PythonPackage.VCXFraming_initialize(self, system)

    def mountBase_GoTo_Home(self):
        return _HC_API_PythonPackage.VCXFraming_mountBase_GoTo_Home(self)

    def mountBase_Go_MechanicalOriginFrame(self, mechSpace, omega):
        return _HC_API_PythonPackage.VCXFraming_mountBase_Go_MechanicalOriginFrame(self, mechSpace, omega)

    def mountBase_Go_ChartCenterFrame(self, chartSpace, omega):
        return _HC_API_PythonPackage.VCXFraming_mountBase_Go_ChartCenterFrame(self, chartSpace, omega)

    def mountBase_Go_HomeFrame(self, displacement, omega):
        return _HC_API_PythonPackage.VCXFraming_mountBase_Go_HomeFrame(self, displacement, omega)

    def chartCenterFrame_To_MechanicalOriginFrame(self, chartCenterSpace):
        r"""
        transform vector in the chartcenter frame to the mechanical origin frame.
        :type chartCenterSpace: :py:class:`Vector3D`
        :param chartCenterSpace:
        :rtype: :py:class:`Vector3D`
        :return: 
        """
        return _HC_API_PythonPackage.VCXFraming_chartCenterFrame_To_MechanicalOriginFrame(self, chartCenterSpace)

    def targetMountHomeFrame_To_MechanicaOriginFrame(self, homeSpace):
        r"""
        transform vector in the home frame to the mechanicalorigin frame. (offset)
        :type homeSpace: :py:class:`Vector3D`
        :param homeSpace:
        :rtype: :py:class:`Vector3D`
        :return: 
        """
        return _HC_API_PythonPackage.VCXFraming_targetMountHomeFrame_To_MechanicaOriginFrame(self, homeSpace)

    def mechanicalOriginFrame_To_HomeFrame(self, mechanicalSpace):
        r"""
        transform vector in the mechanicalorigin frame to the home frame.
        :type mechanicalSpace: :py:class:`Vector3D`
        :param mechanicalSpace:
        :rtype: :py:class:`Vector3D`
        :return: 
        """
        return _HC_API_PythonPackage.VCXFraming_mechanicalOriginFrame_To_HomeFrame(self, mechanicalSpace)

    def mountBaseFrame_To_MechanicalOriginFrame(self, mountbaseSpace):
        r"""
        <summary>
        transform vector in mountbase space to mechanical origin frame space.
        <summary>
        <param name="mountbaseSpace"><param>
        <returns><returns>
        """
        return _HC_API_PythonPackage.VCXFraming_mountBaseFrame_To_MechanicalOriginFrame(self, mountbaseSpace)

    def __init__(self):
        _HC_API_PythonPackage.VCXFraming_swiginit(self, _HC_API_PythonPackage.new_VCXFraming())
    __swig_destroy__ = _HC_API_PythonPackage.delete_VCXFraming

# Register VCXFraming in _HC_API_PythonPackage:
_HC_API_PythonPackage.VCXFraming_swigregister(VCXFraming)
class MOTYZ_Framing(CompositeFrameBase):
    r"""
    <summary>
    The MOTYZ_Framing object can be calibrated to the coordinates of a target chart by calling frame.calibrate() and following the prompts to enter in distance values from the chart center using the range finder. MOTYZ_Frame.
    state can be saved by saving/restoring the chartDisplacement_Ref, chartDisplacement, and liftingCol_refPos variables at any time if the frame is in the same position after calibration.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.MOTYZ_Framing_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.MOTYZ_Framing_className(self)
    zaberPort = property(_HC_API_PythonPackage.MOTYZ_Framing_zaberPort_get, _HC_API_PythonPackage.MOTYZ_Framing_zaberPort_set, doc=r"""
    <summary>
    Serial Port for zaber (ex "COM4")
    <summary>
    """)
    liftingColumnPort = property(_HC_API_PythonPackage.MOTYZ_Framing_liftingColumnPort_get, _HC_API_PythonPackage.MOTYZ_Framing_liftingColumnPort_set, doc=r"""
    <summary>
    Serial Port for Lifting Column. (ex "COM5")
    <summary>
    """)

    def initialize(self, system):
        r"""
        <summary>
        Initialize the frame (always required first)
        <summary>
        <param name="system"><param>
        """
        return _HC_API_PythonPackage.MOTYZ_Framing_initialize(self, system)

    def calibrate(self):
        r"""
        <summary>
        prompt for distance measurement to calibrate the frame.
        <summary>
        """
        return _HC_API_PythonPackage.MOTYZ_Framing_calibrate(self)
    chartDisplacement_Ref = property(_HC_API_PythonPackage.MOTYZ_Framing_chartDisplacement_Ref_get, _HC_API_PythonPackage.MOTYZ_Framing_chartDisplacement_Ref_set, doc=r""" homed chart displacement (set by calibration routine)""")
    liftingCol_refPos = property(_HC_API_PythonPackage.MOTYZ_Framing_liftingCol_refPos_get, _HC_API_PythonPackage.MOTYZ_Framing_liftingCol_refPos_set, doc=r"""
    <summary>
    lifting col referance position (set by calibration routine)
    <summary>
    """)
    currentChartDisplacement = property(_HC_API_PythonPackage.MOTYZ_Framing_currentChartDisplacement_get, _HC_API_PythonPackage.MOTYZ_Framing_currentChartDisplacement_set, doc=r"""
    <summary>
    current chart displacement - read only after calling go_Chart_YZ
    <summary>
    """)
    stageVelocity = property(_HC_API_PythonPackage.MOTYZ_Framing_stageVelocity_get, _HC_API_PythonPackage.MOTYZ_Framing_stageVelocity_set, doc=r"""
    <summary>
    stage velocity to use when moving
    <summary>
    """)
    stageAcceleration = property(_HC_API_PythonPackage.MOTYZ_Framing_stageAcceleration_get, _HC_API_PythonPackage.MOTYZ_Framing_stageAcceleration_set, doc=r"""
    <summary>
    stage acceleration to use when moving
    <summary>
    """)

    def home(self):
        r"""Home all Axis."""
        return _HC_API_PythonPackage.MOTYZ_Framing_home(self)

    def go_Chart_YZ(self, chartDisplacement):
        r"""
        <summary>
        Go to liftingCol_refPos position chartDistance millimeters away from the chart.
        <summary>
        """
        return _HC_API_PythonPackage.MOTYZ_Framing_go_Chart_YZ(self, chartDisplacement)

    def __init__(self):
        _HC_API_PythonPackage.MOTYZ_Framing_swiginit(self, _HC_API_PythonPackage.new_MOTYZ_Framing())
    __swig_destroy__ = _HC_API_PythonPackage.delete_MOTYZ_Framing

# Register MOTYZ_Framing in _HC_API_PythonPackage:
_HC_API_PythonPackage.MOTYZ_Framing_swigregister(MOTYZ_Framing)
class ThorLabsUPLED_SetLighting(DeviceCommandPackage):
    r"""
    <summary>
    Command to set the lighting of a ThorLabs UPLED device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ThorLabsUPLED_SetLighting
    intensityPercent = property(_HC_API_PythonPackage.ThorLabsUPLED_SetLighting_intensityPercent_get, _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_intensityPercent_set)

    def __init__(self):
        _HC_API_PythonPackage.ThorLabsUPLED_SetLighting_swiginit(self, _HC_API_PythonPackage.new_ThorLabsUPLED_SetLighting())

# Register ThorLabsUPLED_SetLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.ThorLabsUPLED_SetLighting_swigregister(ThorLabsUPLED_SetLighting)
class ThorLabsUPLED_DeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the ThorLabs UPLED device.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ThorLabsUPLED_DeviceInfo

    def __init__(self):
        _HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ThorLabsUPLED_DeviceInfo())

# Register ThorLabsUPLED_DeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.ThorLabsUPLED_DeviceInfo_swigregister(ThorLabsUPLED_DeviceInfo)
class ThorLabsUPLED_Controller(HardwareDeviceController):
    r"""
    <summary>
    controller for ThorLabs UPLED devices
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ThorLabsUPLED_Controller_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ThorLabsUPLED_Controller_className(self)

    def __init__(self):
        _HC_API_PythonPackage.ThorLabsUPLED_Controller_swiginit(self, _HC_API_PythonPackage.new_ThorLabsUPLED_Controller())
    __swig_destroy__ = _HC_API_PythonPackage.delete_ThorLabsUPLED_Controller

    def sendIntensityCommand(self, apiDeviceId, intensityPercent):
        return _HC_API_PythonPackage.ThorLabsUPLED_Controller_sendIntensityCommand(self, apiDeviceId, intensityPercent)

# Register ThorLabsUPLED_Controller in _HC_API_PythonPackage:
_HC_API_PythonPackage.ThorLabsUPLED_Controller_swigregister(ThorLabsUPLED_Controller)
class ThousliteCommand_SetLighting(DeviceCommandPackage):
    r"""
    <summary>
    Command to set the lighting of a Thouslite device.
    <summary>
    """

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.ThousliteCommand_SetLighting_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ThousliteCommand_SetLighting_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ThousliteCommand_SetLighting_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ThousliteCommand_SetLighting

    def cloneFrom(self, other):
        return _HC_API_PythonPackage.ThousliteCommand_SetLighting_cloneFrom(self, other)
    recipe = property(_HC_API_PythonPackage.ThousliteCommand_SetLighting_recipe_get, _HC_API_PythonPackage.ThousliteCommand_SetLighting_recipe_set, doc=r"""
    light intensity for the 14 channels.
     0 - 1023
     all 0 will turn off LEDCube power.
     % Channels:
       1  -> White          (Broad spectrum)
       2  -> Orange         (585nm)
       3  -> Lt Orange      (Broad spectrum)
       4  -> Blue-Green     (480nm)
       5  -> Red            (660nm)
       6  -> Green-Blue     (505nm)
       7  -> Green          (520nm)
       8  -> Blue           (445nm)
       9  -> Lt Violet      (420nm)
       10 -> Red            (635nm)
       11 -> Yellow-Grn     (545nm)
       12 -> Dk Violet      (405nm)
       13 -> Red            (670nm)
       14 -> Red/IR         (700/850nm)
    """)

    def __init__(self):
        _HC_API_PythonPackage.ThousliteCommand_SetLighting_swiginit(self, _HC_API_PythonPackage.new_ThousliteCommand_SetLighting())

# Register ThousliteCommand_SetLighting in _HC_API_PythonPackage:
_HC_API_PythonPackage.ThousliteCommand_SetLighting_swigregister(ThousliteCommand_SetLighting)
Thouslite_NALPCODE = cvar.Thouslite_NALPCODE
ThousliteRecipeDescriptions = cvar.ThousliteRecipeDescriptions

class ThousliteDeviceInfo(DeviceInfo):
    r"""
    <summary>
    Device Info for the Thouslite device.
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ThousliteDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ThousliteDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.ThousliteDeviceInfo_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ThousliteDeviceInfo
    cubeId = property(_HC_API_PythonPackage.ThousliteDeviceInfo_cubeId_get, _HC_API_PythonPackage.ThousliteDeviceInfo_cubeId_set, doc=r"""The unique ID of the LEDCube as shown on the side.""")

    def __init__(self):
        _HC_API_PythonPackage.ThousliteDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_ThousliteDeviceInfo())

# Register ThousliteDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.ThousliteDeviceInfo_swigregister(ThousliteDeviceInfo)
class ThousliteController(HardwareDeviceController):
    r"""
    <summary>
    controller for Thouslite devices
    <summary>
    """

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.ThousliteController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.ThousliteController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_ThousliteController
    baudrate = property(_HC_API_PythonPackage.ThousliteController_baudrate_get, _HC_API_PythonPackage.ThousliteController_baudrate_set, doc=r"""
    <summary>
    The baudrate to connect to the controller (9600 for older models, 115200 for newer touch screen controller)
    only used with apiMajorVersion = 2
    <summary>
    """)
    apiMajorVersion = property(_HC_API_PythonPackage.ThousliteController_apiMajorVersion_get, _HC_API_PythonPackage.ThousliteController_apiMajorVersion_set, doc=r"""
    <summary>
    The Api version (1 or 2) to use when communicating with the thouslite, default is 1 (older models)
    <summary>
    """)

    def __init__(self):
        _HC_API_PythonPackage.ThousliteController_swiginit(self, _HC_API_PythonPackage.new_ThousliteController())

# Register ThousliteController in _HC_API_PythonPackage:
_HC_API_PythonPackage.ThousliteController_swigregister(ThousliteController)
class DummyDeviceInfo(DeviceInfo):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DummyDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DummyDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.DummyDeviceInfo_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DummyDeviceInfo
    updateDelayTime_S = property(_HC_API_PythonPackage.DummyDeviceInfo_updateDelayTime_S_get, _HC_API_PythonPackage.DummyDeviceInfo_updateDelayTime_S_set)

    def __init__(self):
        _HC_API_PythonPackage.DummyDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_DummyDeviceInfo())

# Register DummyDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.DummyDeviceInfo_swigregister(DummyDeviceInfo)
class DummyController(DeviceController):
    r""" <summary> Fully Virtual Controller Example used for controlling DummyDevices"""

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

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.DummyController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.DummyController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_DummyController

    def BeginMotion(self, apiDeviceId):
        return _HC_API_PythonPackage.DummyController_BeginMotion(self, apiDeviceId)

    def __init__(self):
        _HC_API_PythonPackage.DummyController_swiginit(self, _HC_API_PythonPackage.new_DummyController())

# Register DummyController in _HC_API_PythonPackage:
_HC_API_PythonPackage.DummyController_swigregister(DummyController)
class CommunicationCommandPackage(DeviceCommandPackage):
    r""" Generic Command to communicate with a device."""

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

    def createSharedPtr(self):
        return _HC_API_PythonPackage.CommunicationCommandPackage_createSharedPtr(self)

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.CommunicationCommandPackage_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.CommunicationCommandPackage_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_CommunicationCommandPackage
    outgoingBuffer = property(_HC_API_PythonPackage.CommunicationCommandPackage_outgoingBuffer_get, _HC_API_PythonPackage.CommunicationCommandPackage_outgoingBuffer_set)

    def __init__(self):
        _HC_API_PythonPackage.CommunicationCommandPackage_swiginit(self, _HC_API_PythonPackage.new_CommunicationCommandPackage())

# Register CommunicationCommandPackage in _HC_API_PythonPackage:
_HC_API_PythonPackage.CommunicationCommandPackage_swigregister(CommunicationCommandPackage)
class LoopBackComDeviceInfo(DeviceInfo):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LoopBackComDeviceInfo_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LoopBackComDeviceInfo_className(self)

    def addCommand(self, package):
        return _HC_API_PythonPackage.LoopBackComDeviceInfo_addCommand(self, package)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LoopBackComDeviceInfo

    def __init__(self):
        _HC_API_PythonPackage.LoopBackComDeviceInfo_swiginit(self, _HC_API_PythonPackage.new_LoopBackComDeviceInfo())

# Register LoopBackComDeviceInfo in _HC_API_PythonPackage:
_HC_API_PythonPackage.LoopBackComDeviceInfo_swigregister(LoopBackComDeviceInfo)
class LoopBackComController(DeviceController):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def staticClassName():
        return _HC_API_PythonPackage.LoopBackComController_staticClassName()

    def className(self):
        return _HC_API_PythonPackage.LoopBackComController_className(self)
    __swig_destroy__ = _HC_API_PythonPackage.delete_LoopBackComController
    port = property(_HC_API_PythonPackage.LoopBackComController_port_get, _HC_API_PythonPackage.LoopBackComController_port_set)

    def __init__(self):
        _HC_API_PythonPackage.LoopBackComController_swiginit(self, _HC_API_PythonPackage.new_LoopBackComController())

# Register LoopBackComController in _HC_API_PythonPackage:
_HC_API_PythonPackage.LoopBackComController_swigregister(LoopBackComController)

def basicFunc(a, b):
    return _HC_API_PythonPackage.basicFunc(a, b)
class controlGuiInterface(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _HC_API_PythonPackage.controlGuiInterface_swiginit(self, _HC_API_PythonPackage.new_controlGuiInterface())
    __swig_destroy__ = _HC_API_PythonPackage.delete_controlGuiInterface

    def open(self, argc, argv):
        r""" open the control GUI in a seperate thread."""
        return _HC_API_PythonPackage.controlGuiInterface_open(self, argc, argv)

    def update(self):
        return _HC_API_PythonPackage.controlGuiInterface_update(self)
    noUserLoadMode = property(_HC_API_PythonPackage.controlGuiInterface_noUserLoadMode_get, _HC_API_PythonPackage.controlGuiInterface_noUserLoadMode_set, doc=r""" wait until the GUI is closed.""")

# Register controlGuiInterface in _HC_API_PythonPackage:
_HC_API_PythonPackage.controlGuiInterface_swigregister(controlGuiInterface)