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

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__)


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__ = _imslib.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        _imslib.PostDelay_swiginit(self, _imslib.new_PostDelay(*args))

    def count(self):
        return _imslib.PostDelay_count(self)

    def __add__(self, *args):
        return _imslib.PostDelay___add__(self, *args)

    def __sub__(self, *args):
        return _imslib.PostDelay___sub__(self, *args)

    def __neg__(self):
        return _imslib.PostDelay___neg__(self)

    def __mul__(self, scale):
        return _imslib.PostDelay___mul__(self, scale)

    def __truediv__(self, scale):
        return _imslib.PostDelay___truediv__(self, scale)

    def __eq__(self, *args):
        return _imslib.PostDelay___eq__(self, *args)

    def __lt__(self, *args):
        return _imslib.PostDelay___lt__(self, *args)

    def __le__(self, *args):
        return _imslib.PostDelay___le__(self, *args)

    def __gt__(self, *args):
        return _imslib.PostDelay___gt__(self, *args)

    def __ge__(self, *args):
        return _imslib.PostDelay___ge__(self, *args)

    def __str__(self):
        return _imslib.PostDelay___str__(self)
    __swig_destroy__ = _imslib.delete_PostDelay

# Register PostDelay in _imslib:
_imslib.PostDelay_swigregister(PostDelay)
class UnitIntDuration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.UnitIntDuration_swiginit(self, _imslib.new_UnitIntDuration(*args))

    def count(self):
        return _imslib.UnitIntDuration_count(self)

    def __add__(self, *args):
        return _imslib.UnitIntDuration___add__(self, *args)

    def __sub__(self, *args):
        return _imslib.UnitIntDuration___sub__(self, *args)

    def __neg__(self):
        return _imslib.UnitIntDuration___neg__(self)

    def __mul__(self, scale):
        return _imslib.UnitIntDuration___mul__(self, scale)

    def __truediv__(self, scale):
        return _imslib.UnitIntDuration___truediv__(self, scale)

    def __eq__(self, *args):
        return _imslib.UnitIntDuration___eq__(self, *args)

    def __lt__(self, *args):
        return _imslib.UnitIntDuration___lt__(self, *args)

    def __le__(self, *args):
        return _imslib.UnitIntDuration___le__(self, *args)

    def __gt__(self, *args):
        return _imslib.UnitIntDuration___gt__(self, *args)

    def __ge__(self, *args):
        return _imslib.UnitIntDuration___ge__(self, *args)

    def __str__(self):
        return _imslib.UnitIntDuration___str__(self)
    __swig_destroy__ = _imslib.delete_UnitIntDuration

# Register UnitIntDuration in _imslib:
_imslib.UnitIntDuration_swigregister(UnitIntDuration)
class UnitFloatDuration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.UnitFloatDuration_swiginit(self, _imslib.new_UnitFloatDuration(*args))

    def count(self):
        return _imslib.UnitFloatDuration_count(self)

    def __add__(self, *args):
        return _imslib.UnitFloatDuration___add__(self, *args)

    def __sub__(self, *args):
        return _imslib.UnitFloatDuration___sub__(self, *args)

    def __neg__(self):
        return _imslib.UnitFloatDuration___neg__(self)

    def __mul__(self, scale):
        return _imslib.UnitFloatDuration___mul__(self, scale)

    def __truediv__(self, scale):
        return _imslib.UnitFloatDuration___truediv__(self, scale)

    def __eq__(self, *args):
        return _imslib.UnitFloatDuration___eq__(self, *args)

    def __lt__(self, *args):
        return _imslib.UnitFloatDuration___lt__(self, *args)

    def __le__(self, *args):
        return _imslib.UnitFloatDuration___le__(self, *args)

    def __gt__(self, *args):
        return _imslib.UnitFloatDuration___gt__(self, *args)

    def __ge__(self, *args):
        return _imslib.UnitFloatDuration___ge__(self, *args)

    def __str__(self):
        return _imslib.UnitFloatDuration___str__(self)
    __swig_destroy__ = _imslib.delete_UnitFloatDuration

# Register UnitFloatDuration in _imslib:
_imslib.UnitFloatDuration_swigregister(UnitFloatDuration)
class NanoSeconds(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.NanoSeconds_swiginit(self, _imslib.new_NanoSeconds(*args))

    def count(self):
        return _imslib.NanoSeconds_count(self)

    def __add__(self, *args):
        return _imslib.NanoSeconds___add__(self, *args)

    def __sub__(self, *args):
        return _imslib.NanoSeconds___sub__(self, *args)

    def __neg__(self):
        return _imslib.NanoSeconds___neg__(self)

    def __mul__(self, scale):
        return _imslib.NanoSeconds___mul__(self, scale)

    def __truediv__(self, scale):
        return _imslib.NanoSeconds___truediv__(self, scale)

    def __eq__(self, *args):
        return _imslib.NanoSeconds___eq__(self, *args)

    def __lt__(self, *args):
        return _imslib.NanoSeconds___lt__(self, *args)

    def __le__(self, *args):
        return _imslib.NanoSeconds___le__(self, *args)

    def __gt__(self, *args):
        return _imslib.NanoSeconds___gt__(self, *args)

    def __ge__(self, *args):
        return _imslib.NanoSeconds___ge__(self, *args)

    def __str__(self):
        return _imslib.NanoSeconds___str__(self)
    __swig_destroy__ = _imslib.delete_NanoSeconds

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register ByteVector in _imslib:
_imslib.ByteVector_swigregister(ByteVector)
class UUID(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 _imslib.UUID_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _imslib.UUID___nonzero__(self)

    def __bool__(self):
        return _imslib.UUID___bool__(self)

    def __len__(self):
        return _imslib.UUID___len__(self)

    def __getslice__(self, i, j):
        return _imslib.UUID___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _imslib.UUID___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _imslib.UUID___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _imslib.UUID___delitem__(self, *args)

    def __getitem__(self, *args):
        return _imslib.UUID___getitem__(self, *args)

    def __setitem__(self, *args):
        return _imslib.UUID___setitem__(self, *args)

    def __init__(self, *args):
        _imslib.UUID_swiginit(self, _imslib.new_UUID(*args))

    def empty(self):
        return _imslib.UUID_empty(self)

    def size(self):
        return _imslib.UUID_size(self)

    def swap(self, v):
        return _imslib.UUID_swap(self, v)

    def begin(self):
        return _imslib.UUID_begin(self)

    def end(self):
        return _imslib.UUID_end(self)

    def rbegin(self):
        return _imslib.UUID_rbegin(self)

    def rend(self):
        return _imslib.UUID_rend(self)

    def front(self):
        return _imslib.UUID_front(self)

    def back(self):
        return _imslib.UUID_back(self)

    def fill(self, u):
        return _imslib.UUID_fill(self, u)

    def __str__(self):
        return _imslib.UUID___str__(self)
    __swig_destroy__ = _imslib.delete_UUID

# Register UUID in _imslib:
_imslib.UUID_swigregister(UUID)
class VelGain(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 _imslib.VelGain_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _imslib.VelGain___nonzero__(self)

    def __bool__(self):
        return _imslib.VelGain___bool__(self)

    def __len__(self):
        return _imslib.VelGain___len__(self)

    def __getslice__(self, i, j):
        return _imslib.VelGain___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _imslib.VelGain___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _imslib.VelGain___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _imslib.VelGain___delitem__(self, *args)

    def __getitem__(self, *args):
        return _imslib.VelGain___getitem__(self, *args)

    def __setitem__(self, *args):
        return _imslib.VelGain___setitem__(self, *args)

    def __init__(self, *args):
        _imslib.VelGain_swiginit(self, _imslib.new_VelGain(*args))

    def empty(self):
        return _imslib.VelGain_empty(self)

    def size(self):
        return _imslib.VelGain_size(self)

    def swap(self, v):
        return _imslib.VelGain_swap(self, v)

    def begin(self):
        return _imslib.VelGain_begin(self)

    def end(self):
        return _imslib.VelGain_end(self)

    def rbegin(self):
        return _imslib.VelGain_rbegin(self)

    def rend(self):
        return _imslib.VelGain_rend(self)

    def front(self):
        return _imslib.VelGain_front(self)

    def back(self):
        return _imslib.VelGain_back(self)

    def fill(self, u):
        return _imslib.VelGain_fill(self, u)
    __swig_destroy__ = _imslib.delete_VelGain

# Register VelGain in _imslib:
_imslib.VelGain_swigregister(VelGain)

def UUID_Stream(stream, uuid):
    return _imslib.UUID_Stream(stream, uuid)
SHARED_PTR_DISOWN = _imslib.SHARED_PTR_DISOWN

def SeqEntry_Stream(stream, seq):
    return _imslib.SeqEntry_Stream(stream, seq)

def __lshift__(*args):
    return _imslib.__lshift__(*args)
class ListBase_SequenceEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.ListBase_SequenceEntry_begin(self)

    def end(self):
        return _imslib.ListBase_SequenceEntry_end(self)

    def cbegin(self):
        return _imslib.ListBase_SequenceEntry_cbegin(self)

    def cend(self):
        return _imslib.ListBase_SequenceEntry_cend(self)

    def __getitem__(self, i):
        return _imslib.ListBase_SequenceEntry___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.ListBase_SequenceEntry___setitem__(self, i, val)

    def __len__(self):
        return _imslib.ListBase_SequenceEntry___len__(self)

    def __bool__(self):
        return _imslib.ListBase_SequenceEntry___bool__(self)

    def append(self, val):
        return _imslib.ListBase_SequenceEntry_append(self, val)

    def pop(self):
        return _imslib.ListBase_SequenceEntry_pop(self)

    def __contains__(self, val):
        return _imslib.ListBase_SequenceEntry___contains__(self, val)

    def __str__(self):
        return _imslib.ListBase_SequenceEntry___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.ListBase_SequenceEntry_swiginit(self, _imslib.new_ListBase_SequenceEntry(*args))

    def assign(self, n, val):
        return _imslib.ListBase_SequenceEntry_assign(self, n, val)

    def resize(self, n):
        return _imslib.ListBase_SequenceEntry_resize(self, n)

    def clear(self):
        return _imslib.ListBase_SequenceEntry_clear(self)

    def push_back(self, value):
        return _imslib.ListBase_SequenceEntry_push_back(self, value)

    def pop_back(self):
        return _imslib.ListBase_SequenceEntry_pop_back(self)

    def push_front(self, value):
        return _imslib.ListBase_SequenceEntry_push_front(self, value)

    def pop_front(self):
        return _imslib.ListBase_SequenceEntry_pop_front(self)

    def empty(self):
        return _imslib.ListBase_SequenceEntry_empty(self)

    def size(self):
        return _imslib.ListBase_SequenceEntry_size(self)
    GetUUID = property(_imslib.ListBase_SequenceEntry_GetUUID_get)
    Name = property(_imslib.ListBase_SequenceEntry_Name_get, _imslib.ListBase_SequenceEntry_Name_set)
    ModifiedTimeFormat = property(_imslib.ListBase_SequenceEntry_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_ListBase_SequenceEntry

# Register ListBase_SequenceEntry in _imslib:
_imslib.ListBase_SequenceEntry_swigregister(ListBase_SequenceEntry)
class ListBase_ImageGroup(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.ListBase_ImageGroup_begin(self)

    def end(self):
        return _imslib.ListBase_ImageGroup_end(self)

    def cbegin(self):
        return _imslib.ListBase_ImageGroup_cbegin(self)

    def cend(self):
        return _imslib.ListBase_ImageGroup_cend(self)

    def __getitem__(self, i):
        return _imslib.ListBase_ImageGroup___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.ListBase_ImageGroup___setitem__(self, i, val)

    def __len__(self):
        return _imslib.ListBase_ImageGroup___len__(self)

    def __bool__(self):
        return _imslib.ListBase_ImageGroup___bool__(self)

    def append(self, val):
        return _imslib.ListBase_ImageGroup_append(self, val)

    def pop(self):
        return _imslib.ListBase_ImageGroup_pop(self)

    def __contains__(self, val):
        return _imslib.ListBase_ImageGroup___contains__(self, val)

    def __str__(self):
        return _imslib.ListBase_ImageGroup___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.ListBase_ImageGroup_swiginit(self, _imslib.new_ListBase_ImageGroup(*args))

    def assign(self, n, val):
        return _imslib.ListBase_ImageGroup_assign(self, n, val)

    def resize(self, n):
        return _imslib.ListBase_ImageGroup_resize(self, n)

    def clear(self):
        return _imslib.ListBase_ImageGroup_clear(self)

    def push_back(self, value):
        return _imslib.ListBase_ImageGroup_push_back(self, value)

    def pop_back(self):
        return _imslib.ListBase_ImageGroup_pop_back(self)

    def push_front(self, value):
        return _imslib.ListBase_ImageGroup_push_front(self, value)

    def pop_front(self):
        return _imslib.ListBase_ImageGroup_pop_front(self)

    def empty(self):
        return _imslib.ListBase_ImageGroup_empty(self)

    def size(self):
        return _imslib.ListBase_ImageGroup_size(self)
    GetUUID = property(_imslib.ListBase_ImageGroup_GetUUID_get)
    Name = property(_imslib.ListBase_ImageGroup_Name_get, _imslib.ListBase_ImageGroup_Name_set)
    ModifiedTimeFormat = property(_imslib.ListBase_ImageGroup_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_ListBase_ImageGroup

# Register ListBase_ImageGroup in _imslib:
_imslib.ListBase_ImageGroup_swigregister(ListBase_ImageGroup)
class ListBase_CompensationFunction(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.ListBase_CompensationFunction_begin(self)

    def end(self):
        return _imslib.ListBase_CompensationFunction_end(self)

    def cbegin(self):
        return _imslib.ListBase_CompensationFunction_cbegin(self)

    def cend(self):
        return _imslib.ListBase_CompensationFunction_cend(self)

    def __getitem__(self, i):
        return _imslib.ListBase_CompensationFunction___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.ListBase_CompensationFunction___setitem__(self, i, val)

    def __len__(self):
        return _imslib.ListBase_CompensationFunction___len__(self)

    def __bool__(self):
        return _imslib.ListBase_CompensationFunction___bool__(self)

    def append(self, val):
        return _imslib.ListBase_CompensationFunction_append(self, val)

    def pop(self):
        return _imslib.ListBase_CompensationFunction_pop(self)

    def __contains__(self, val):
        return _imslib.ListBase_CompensationFunction___contains__(self, val)

    def __str__(self):
        return _imslib.ListBase_CompensationFunction___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.ListBase_CompensationFunction_swiginit(self, _imslib.new_ListBase_CompensationFunction(*args))

    def assign(self, n, val):
        return _imslib.ListBase_CompensationFunction_assign(self, n, val)

    def resize(self, n):
        return _imslib.ListBase_CompensationFunction_resize(self, n)

    def clear(self):
        return _imslib.ListBase_CompensationFunction_clear(self)

    def push_back(self, value):
        return _imslib.ListBase_CompensationFunction_push_back(self, value)

    def pop_back(self):
        return _imslib.ListBase_CompensationFunction_pop_back(self)

    def push_front(self, value):
        return _imslib.ListBase_CompensationFunction_push_front(self, value)

    def pop_front(self):
        return _imslib.ListBase_CompensationFunction_pop_front(self)

    def empty(self):
        return _imslib.ListBase_CompensationFunction_empty(self)

    def size(self):
        return _imslib.ListBase_CompensationFunction_size(self)
    GetUUID = property(_imslib.ListBase_CompensationFunction_GetUUID_get)
    Name = property(_imslib.ListBase_CompensationFunction_Name_get, _imslib.ListBase_CompensationFunction_Name_set)
    ModifiedTimeFormat = property(_imslib.ListBase_CompensationFunction_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_ListBase_CompensationFunction

# Register ListBase_CompensationFunction in _imslib:
_imslib.ListBase_CompensationFunction_swigregister(ListBase_CompensationFunction)
class ListBase_CompensationPointSpecification(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.ListBase_CompensationPointSpecification_begin(self)

    def end(self):
        return _imslib.ListBase_CompensationPointSpecification_end(self)

    def cbegin(self):
        return _imslib.ListBase_CompensationPointSpecification_cbegin(self)

    def cend(self):
        return _imslib.ListBase_CompensationPointSpecification_cend(self)

    def __getitem__(self, i):
        return _imslib.ListBase_CompensationPointSpecification___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.ListBase_CompensationPointSpecification___setitem__(self, i, val)

    def __len__(self):
        return _imslib.ListBase_CompensationPointSpecification___len__(self)

    def __bool__(self):
        return _imslib.ListBase_CompensationPointSpecification___bool__(self)

    def append(self, val):
        return _imslib.ListBase_CompensationPointSpecification_append(self, val)

    def pop(self):
        return _imslib.ListBase_CompensationPointSpecification_pop(self)

    def __contains__(self, val):
        return _imslib.ListBase_CompensationPointSpecification___contains__(self, val)

    def __str__(self):
        return _imslib.ListBase_CompensationPointSpecification___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.ListBase_CompensationPointSpecification_swiginit(self, _imslib.new_ListBase_CompensationPointSpecification(*args))

    def assign(self, n, val):
        return _imslib.ListBase_CompensationPointSpecification_assign(self, n, val)

    def resize(self, n):
        return _imslib.ListBase_CompensationPointSpecification_resize(self, n)

    def clear(self):
        return _imslib.ListBase_CompensationPointSpecification_clear(self)

    def push_back(self, value):
        return _imslib.ListBase_CompensationPointSpecification_push_back(self, value)

    def pop_back(self):
        return _imslib.ListBase_CompensationPointSpecification_pop_back(self)

    def push_front(self, value):
        return _imslib.ListBase_CompensationPointSpecification_push_front(self, value)

    def pop_front(self):
        return _imslib.ListBase_CompensationPointSpecification_pop_front(self)

    def empty(self):
        return _imslib.ListBase_CompensationPointSpecification_empty(self)

    def size(self):
        return _imslib.ListBase_CompensationPointSpecification_size(self)
    GetUUID = property(_imslib.ListBase_CompensationPointSpecification_GetUUID_get)
    Name = property(_imslib.ListBase_CompensationPointSpecification_Name_get, _imslib.ListBase_CompensationPointSpecification_Name_set)
    ModifiedTimeFormat = property(_imslib.ListBase_CompensationPointSpecification_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_ListBase_CompensationPointSpecification

# Register ListBase_CompensationPointSpecification in _imslib:
_imslib.ListBase_CompensationPointSpecification_swigregister(ListBase_CompensationPointSpecification)
class StringList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.StringList_begin(self)

    def end(self):
        return _imslib.StringList_end(self)

    def cbegin(self):
        return _imslib.StringList_cbegin(self)

    def cend(self):
        return _imslib.StringList_cend(self)

    def __getitem__(self, i):
        return _imslib.StringList___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.StringList___setitem__(self, i, val)

    def __len__(self):
        return _imslib.StringList___len__(self)

    def __bool__(self):
        return _imslib.StringList___bool__(self)

    def append(self, val):
        return _imslib.StringList_append(self, val)

    def pop(self):
        return _imslib.StringList_pop(self)

    def __contains__(self, val):
        return _imslib.StringList___contains__(self, val)

    def __str__(self):
        return _imslib.StringList___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.StringList_swiginit(self, _imslib.new_StringList(*args))

    def assign(self, n, val):
        return _imslib.StringList_assign(self, n, val)

    def resize(self, n):
        return _imslib.StringList_resize(self, n)

    def clear(self):
        return _imslib.StringList_clear(self)

    def push_back(self, value):
        return _imslib.StringList_push_back(self, value)

    def pop_back(self):
        return _imslib.StringList_pop_back(self)

    def push_front(self, value):
        return _imslib.StringList_push_front(self, value)

    def pop_front(self):
        return _imslib.StringList_pop_front(self)

    def empty(self):
        return _imslib.StringList_empty(self)

    def size(self):
        return _imslib.StringList_size(self)
    GetUUID = property(_imslib.StringList_GetUUID_get)
    Name = property(_imslib.StringList_Name_get, _imslib.StringList_Name_set)
    ModifiedTimeFormat = property(_imslib.StringList_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_StringList

# Register StringList in _imslib:
_imslib.StringList_swigregister(StringList)
class DequeBase_ImagePoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.DequeBase_ImagePoint_begin(self)

    def end(self):
        return _imslib.DequeBase_ImagePoint_end(self)

    def cbegin(self):
        return _imslib.DequeBase_ImagePoint_cbegin(self)

    def cend(self):
        return _imslib.DequeBase_ImagePoint_cend(self)

    def __getitem__(self, i):
        return _imslib.DequeBase_ImagePoint___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.DequeBase_ImagePoint___setitem__(self, i, val)

    def __len__(self):
        return _imslib.DequeBase_ImagePoint___len__(self)

    def __bool__(self):
        return _imslib.DequeBase_ImagePoint___bool__(self)

    def append(self, val):
        return _imslib.DequeBase_ImagePoint_append(self, val)

    def pop(self):
        return _imslib.DequeBase_ImagePoint_pop(self)

    def __contains__(self, val):
        return _imslib.DequeBase_ImagePoint___contains__(self, val)

    def __str__(self):
        return _imslib.DequeBase_ImagePoint___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.DequeBase_ImagePoint_swiginit(self, _imslib.new_DequeBase_ImagePoint(*args))

    def clear(self):
        return _imslib.DequeBase_ImagePoint_clear(self)

    def add(self, value):
        return _imslib.DequeBase_ImagePoint_add(self, value)

    def remove(self):
        return _imslib.DequeBase_ImagePoint_remove(self)

    def push_front(self, value):
        return _imslib.DequeBase_ImagePoint_push_front(self, value)

    def pop_front(self):
        return _imslib.DequeBase_ImagePoint_pop_front(self)

    def size(self):
        return _imslib.DequeBase_ImagePoint_size(self)
    GetUUID = property(_imslib.DequeBase_ImagePoint_GetUUID_get)
    Name = property(_imslib.DequeBase_ImagePoint_Name_get, _imslib.DequeBase_ImagePoint_Name_set)
    ModifiedTimeFormat = property(_imslib.DequeBase_ImagePoint_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_DequeBase_ImagePoint

# Register DequeBase_ImagePoint in _imslib:
_imslib.DequeBase_ImagePoint_swigregister(DequeBase_ImagePoint)
class DequeBase_Image(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.DequeBase_Image_begin(self)

    def end(self):
        return _imslib.DequeBase_Image_end(self)

    def cbegin(self):
        return _imslib.DequeBase_Image_cbegin(self)

    def cend(self):
        return _imslib.DequeBase_Image_cend(self)

    def __getitem__(self, i):
        return _imslib.DequeBase_Image___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.DequeBase_Image___setitem__(self, i, val)

    def __len__(self):
        return _imslib.DequeBase_Image___len__(self)

    def __bool__(self):
        return _imslib.DequeBase_Image___bool__(self)

    def append(self, val):
        return _imslib.DequeBase_Image_append(self, val)

    def pop(self):
        return _imslib.DequeBase_Image_pop(self)

    def __contains__(self, val):
        return _imslib.DequeBase_Image___contains__(self, val)

    def __str__(self):
        return _imslib.DequeBase_Image___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.DequeBase_Image_swiginit(self, _imslib.new_DequeBase_Image(*args))

    def clear(self):
        return _imslib.DequeBase_Image_clear(self)

    def add(self, value):
        return _imslib.DequeBase_Image_add(self, value)

    def remove(self):
        return _imslib.DequeBase_Image_remove(self)

    def push_front(self, value):
        return _imslib.DequeBase_Image_push_front(self, value)

    def pop_front(self):
        return _imslib.DequeBase_Image_pop_front(self)

    def size(self):
        return _imslib.DequeBase_Image_size(self)
    GetUUID = property(_imslib.DequeBase_Image_GetUUID_get)
    Name = property(_imslib.DequeBase_Image_Name_get, _imslib.DequeBase_Image_Name_set)
    ModifiedTimeFormat = property(_imslib.DequeBase_Image_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_DequeBase_Image

# Register DequeBase_Image in _imslib:
_imslib.DequeBase_Image_swigregister(DequeBase_Image)
class DequeBase_CompensationPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.DequeBase_CompensationPoint_begin(self)

    def end(self):
        return _imslib.DequeBase_CompensationPoint_end(self)

    def cbegin(self):
        return _imslib.DequeBase_CompensationPoint_cbegin(self)

    def cend(self):
        return _imslib.DequeBase_CompensationPoint_cend(self)

    def __getitem__(self, i):
        return _imslib.DequeBase_CompensationPoint___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.DequeBase_CompensationPoint___setitem__(self, i, val)

    def __len__(self):
        return _imslib.DequeBase_CompensationPoint___len__(self)

    def __bool__(self):
        return _imslib.DequeBase_CompensationPoint___bool__(self)

    def append(self, val):
        return _imslib.DequeBase_CompensationPoint_append(self, val)

    def pop(self):
        return _imslib.DequeBase_CompensationPoint_pop(self)

    def __contains__(self, val):
        return _imslib.DequeBase_CompensationPoint___contains__(self, val)

    def __str__(self):
        return _imslib.DequeBase_CompensationPoint___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.DequeBase_CompensationPoint_swiginit(self, _imslib.new_DequeBase_CompensationPoint(*args))

    def clear(self):
        return _imslib.DequeBase_CompensationPoint_clear(self)

    def add(self, value):
        return _imslib.DequeBase_CompensationPoint_add(self, value)

    def remove(self):
        return _imslib.DequeBase_CompensationPoint_remove(self)

    def push_front(self, value):
        return _imslib.DequeBase_CompensationPoint_push_front(self, value)

    def pop_front(self):
        return _imslib.DequeBase_CompensationPoint_pop_front(self)

    def size(self):
        return _imslib.DequeBase_CompensationPoint_size(self)
    GetUUID = property(_imslib.DequeBase_CompensationPoint_GetUUID_get)
    Name = property(_imslib.DequeBase_CompensationPoint_Name_get, _imslib.DequeBase_CompensationPoint_Name_set)
    ModifiedTimeFormat = property(_imslib.DequeBase_CompensationPoint_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_DequeBase_CompensationPoint

# Register DequeBase_CompensationPoint in _imslib:
_imslib.DequeBase_CompensationPoint_swigregister(DequeBase_CompensationPoint)
class DequeBase_CompensationTable(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _imslib.DequeBase_CompensationTable_begin(self)

    def end(self):
        return _imslib.DequeBase_CompensationTable_end(self)

    def cbegin(self):
        return _imslib.DequeBase_CompensationTable_cbegin(self)

    def cend(self):
        return _imslib.DequeBase_CompensationTable_cend(self)

    def __getitem__(self, i):
        return _imslib.DequeBase_CompensationTable___getitem__(self, i)

    def __setitem__(self, i, val):
        return _imslib.DequeBase_CompensationTable___setitem__(self, i, val)

    def __len__(self):
        return _imslib.DequeBase_CompensationTable___len__(self)

    def __bool__(self):
        return _imslib.DequeBase_CompensationTable___bool__(self)

    def append(self, val):
        return _imslib.DequeBase_CompensationTable_append(self, val)

    def pop(self):
        return _imslib.DequeBase_CompensationTable_pop(self)

    def __contains__(self, val):
        return _imslib.DequeBase_CompensationTable___contains__(self, val)

    def __str__(self):
        return _imslib.DequeBase_CompensationTable___str__(self)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __eq__(self, rhs):
        eq = True
        for i in range(len(self)):
            if self[i] != rhs[i]:
                eq = False
        return eq


    def __init__(self, *args):
        _imslib.DequeBase_CompensationTable_swiginit(self, _imslib.new_DequeBase_CompensationTable(*args))

    def clear(self):
        return _imslib.DequeBase_CompensationTable_clear(self)

    def add(self, value):
        return _imslib.DequeBase_CompensationTable_add(self, value)

    def remove(self):
        return _imslib.DequeBase_CompensationTable_remove(self)

    def push_front(self, value):
        return _imslib.DequeBase_CompensationTable_push_front(self, value)

    def pop_front(self):
        return _imslib.DequeBase_CompensationTable_pop_front(self)

    def size(self):
        return _imslib.DequeBase_CompensationTable_size(self)
    GetUUID = property(_imslib.DequeBase_CompensationTable_GetUUID_get)
    Name = property(_imslib.DequeBase_CompensationTable_Name_get, _imslib.DequeBase_CompensationTable_Name_set)
    ModifiedTimeFormat = property(_imslib.DequeBase_CompensationTable_ModifiedTimeFormat_get)
    __swig_destroy__ = _imslib.delete_DequeBase_CompensationTable

# Register DequeBase_CompensationTable in _imslib:
_imslib.DequeBase_CompensationTable_swigregister(DequeBase_CompensationTable)
class LibVersion(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def GetMajor():
        return _imslib.LibVersion_GetMajor()

    @staticmethod
    def GetMinor():
        return _imslib.LibVersion_GetMinor()

    @staticmethod
    def GetPatch():
        return _imslib.LibVersion_GetPatch()

    @staticmethod
    def GetVersion():
        return _imslib.LibVersion_GetVersion()

    @staticmethod
    def IsAtLeast(major, minor, patch):
        return _imslib.LibVersion_IsAtLeast(major, minor, patch)

    @staticmethod
    def HasFeature(name):
        return _imslib.LibVersion_HasFeature(name)

    def __init__(self):
        _imslib.LibVersion_swiginit(self, _imslib.new_LibVersion())
    __swig_destroy__ = _imslib.delete_LibVersion

# Register LibVersion in _imslib:
_imslib.LibVersion_swigregister(LibVersion)
class Frequency(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.Frequency_swiginit(self, _imslib.new_Frequency(*args))

    def assign(self, *args):
        return _imslib.Frequency_assign(self, *args)

    def __add__(self, f):
        return _imslib.Frequency___add__(self, f)

    def __iadd__(self, f):
        return _imslib.Frequency___iadd__(self, f)

    def __sub__(self, f):
        return _imslib.Frequency___sub__(self, f)

    def __isub__(self, f):
        return _imslib.Frequency___isub__(self, f)

    def __float__(self):
        return _imslib.Frequency___float__(self)

    def __str__(self):
        return _imslib.Frequency___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec) + "Hz"

    value = property(_imslib.Frequency_value_get, _imslib.Frequency_value_set)
    __swig_destroy__ = _imslib.delete_Frequency

# Register Frequency in _imslib:
_imslib.Frequency_swigregister(Frequency)
class kHz(Frequency):
    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):
        _imslib.kHz_swiginit(self, _imslib.new_kHz(*args))

    def assign(self, *args):
        return _imslib.kHz_assign(self, *args)

    def __add__(self, *args):
        return _imslib.kHz___add__(self, *args)

    def __iadd__(self, *args):
        return _imslib.kHz___iadd__(self, *args)

    def __sub__(self, *args):
        return _imslib.kHz___sub__(self, *args)

    def __isub__(self, *args):
        return _imslib.kHz___isub__(self, *args)

    def __float__(self):
        return _imslib.kHz___float__(self)

    def __str__(self):
        return _imslib.kHz___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec) + "kHz"

    value = property(_imslib.kHz_value_get, _imslib.kHz_value_set)
    __swig_destroy__ = _imslib.delete_kHz

# Register kHz in _imslib:
_imslib.kHz_swigregister(kHz)
class MHz(Frequency):
    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):
        _imslib.MHz_swiginit(self, _imslib.new_MHz(*args))

    def assign(self, *args):
        return _imslib.MHz_assign(self, *args)

    def __add__(self, *args):
        return _imslib.MHz___add__(self, *args)

    def __iadd__(self, *args):
        return _imslib.MHz___iadd__(self, *args)

    def __sub__(self, *args):
        return _imslib.MHz___sub__(self, *args)

    def __isub__(self, *args):
        return _imslib.MHz___isub__(self, *args)

    def __float__(self):
        return _imslib.MHz___float__(self)

    def __str__(self):
        return _imslib.MHz___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec) + "MHz"

    value = property(_imslib.MHz_value_get, _imslib.MHz_value_set)
    __swig_destroy__ = _imslib.delete_MHz

# Register MHz in _imslib:
_imslib.MHz_swigregister(MHz)
class Percent(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.Percent_swiginit(self, _imslib.new_Percent(*args))

    def __float__(self):
        return _imslib.Percent___float__(self)

    def __str__(self):
        return _imslib.Percent___str__(self)
    value = property(_imslib.Percent_value_get, _imslib.Percent_value_set)
    __swig_destroy__ = _imslib.delete_Percent

# Register Percent in _imslib:
_imslib.Percent_swigregister(Percent)
class Degrees(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, arg):
        _imslib.Degrees_swiginit(self, _imslib.new_Degrees(arg))

    def __float__(self):
        return _imslib.Degrees___float__(self)

    def __str__(self):
        return _imslib.Degrees___str__(self)
    value = property(_imslib.Degrees_value_get, _imslib.Degrees_value_set)
    __swig_destroy__ = _imslib.delete_Degrees

# Register Degrees in _imslib:
_imslib.Degrees_swigregister(Degrees)
class FAP(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    freq = property(_imslib.FAP_freq_get, _imslib.FAP_freq_set)
    ampl = property(_imslib.FAP_ampl_get, _imslib.FAP_ampl_set)
    phase = property(_imslib.FAP_phase_get, _imslib.FAP_phase_set)

    def __eq__(self, other):
        return _imslib.FAP___eq__(self, other)

    def __ne__(self, other):
        return _imslib.FAP___ne__(self, other)

    def __str__(self):
        return _imslib.FAP___str__(self)

    def __init__(self, *args):
        _imslib.FAP_swiginit(self, _imslib.new_FAP(*args))
    __swig_destroy__ = _imslib.delete_FAP

# Register FAP in _imslib:
_imslib.FAP_swigregister(FAP)
class RFChannel(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def incr(self):
        return _imslib.RFChannel_incr(self)

    def decr(self):
        return _imslib.RFChannel_decr(self)

    def IsAll(self):
        return _imslib.RFChannel_IsAll(self)
    value = property(_imslib.RFChannel_value_get, _imslib.RFChannel_value_set)

    def __init__(self, *args):
        _imslib.RFChannel_swiginit(self, _imslib.new_RFChannel(*args))

    def __int__(self):
        return _imslib.RFChannel___int__(self)

    def __index__(self):
        return _imslib.RFChannel___index__(self)

    def __str__(self):
        return _imslib.RFChannel___str__(self)

    def __iter__(self):
        return iter(range(RFChannel.min, RFChannel.max + 1))


    def __add__(self, delta):
        return _imslib.RFChannel___add__(self, delta)

    def __sub__(self, delta):
        return _imslib.RFChannel___sub__(self, delta)

    def __iadd__(self, delta):
        return _imslib.RFChannel___iadd__(self, delta)

    def __isub__(self, delta):
        return _imslib.RFChannel___isub__(self, delta)

    def next(self):
        return _imslib.RFChannel_next(self)

    def prev(self):
        return _imslib.RFChannel_prev(self)

    def reset(self):
        return _imslib.RFChannel_reset(self)

    def __eq__(self, other):
        return _imslib.RFChannel___eq__(self, other)

    def __lt__(self, other):
        return _imslib.RFChannel___lt__(self, other)
    __swig_destroy__ = _imslib.delete_RFChannel

# Register RFChannel in _imslib:
_imslib.RFChannel_swigregister(RFChannel)
cvar = _imslib.cvar
RFChannel.min = _imslib.cvar.RFChannel_min
RFChannel.max = _imslib.cvar.RFChannel_max
RFChannel.all = _imslib.cvar.RFChannel_all

ENHANCED_TONE_MODE_NO_SWEEP = _imslib.ENHANCED_TONE_MODE_NO_SWEEP
ENHANCED_TONE_MODE_FREQUENCY_DWELL = _imslib.ENHANCED_TONE_MODE_FREQUENCY_DWELL
ENHANCED_TONE_MODE_FREQUENCY_NO_DWELL = _imslib.ENHANCED_TONE_MODE_FREQUENCY_NO_DWELL
ENHANCED_TONE_MODE_FREQUENCY_FAST_MOD = _imslib.ENHANCED_TONE_MODE_FREQUENCY_FAST_MOD
ENHANCED_TONE_MODE_PHASE_DWELL = _imslib.ENHANCED_TONE_MODE_PHASE_DWELL
ENHANCED_TONE_MODE_PHASE_NO_DWELL = _imslib.ENHANCED_TONE_MODE_PHASE_NO_DWELL
ENHANCED_TONE_MODE_PHASE_FAST_MOD = _imslib.ENHANCED_TONE_MODE_PHASE_FAST_MOD
DAC_CURRENT_REFERENCE_FULL_SCALE = _imslib.DAC_CURRENT_REFERENCE_FULL_SCALE
DAC_CURRENT_REFERENCE_HALF_SCALE = _imslib.DAC_CURRENT_REFERENCE_HALF_SCALE
DAC_CURRENT_REFERENCE_QUARTER_SCALE = _imslib.DAC_CURRENT_REFERENCE_QUARTER_SCALE
DAC_CURRENT_REFERENCE_EIGHTH_SCALE = _imslib.DAC_CURRENT_REFERENCE_EIGHTH_SCALE
class SweepTone(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.SweepTone_swiginit(self, _imslib.new_SweepTone(*args))
    start = property(_imslib.SweepTone_start_get, _imslib.SweepTone_start_set)
    end = property(_imslib.SweepTone_end_get, _imslib.SweepTone_end_set)
    up_ramp = property(_imslib.SweepTone_up_ramp_get, _imslib.SweepTone_up_ramp_set)
    down_ramp = property(_imslib.SweepTone_down_ramp_get, _imslib.SweepTone_down_ramp_set)
    n_steps = property(_imslib.SweepTone_n_steps_get, _imslib.SweepTone_n_steps_set)
    mode = property(_imslib.SweepTone_mode_get, _imslib.SweepTone_mode_set)
    scaling = property(_imslib.SweepTone_scaling_get, _imslib.SweepTone_scaling_set)
    __swig_destroy__ = _imslib.delete_SweepTone

# Register SweepTone in _imslib:
_imslib.SweepTone_swigregister(SweepTone)
class Metre(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, ticks=1.0):
        _imslib.Metre_swiginit(self, _imslib.new_Metre(ticks))

    def __float__(self):
        return _imslib.Metre___float__(self)

    def __str__(self):
        return _imslib.Metre___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec)

    value = property(_imslib.Metre_value_get, _imslib.Metre_value_set)
    __swig_destroy__ = _imslib.delete_Metre

# Register Metre in _imslib:
_imslib.Metre_swigregister(Metre)
class Nanometre(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, ticks=1.0):
        _imslib.Nanometre_swiginit(self, _imslib.new_Nanometre(ticks))

    def __float__(self):
        return _imslib.Nanometre___float__(self)

    def __str__(self):
        return _imslib.Nanometre___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec)

    value = property(_imslib.Nanometre_value_get, _imslib.Nanometre_value_set)
    __swig_destroy__ = _imslib.delete_Nanometre

# Register Nanometre in _imslib:
_imslib.Nanometre_swigregister(Nanometre)
class Micrometre(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, ticks=1.0):
        _imslib.Micrometre_swiginit(self, _imslib.new_Micrometre(ticks))

    def __float__(self):
        return _imslib.Micrometre___float__(self)

    def __str__(self):
        return _imslib.Micrometre___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec)

    value = property(_imslib.Micrometre_value_get, _imslib.Micrometre_value_set)
    __swig_destroy__ = _imslib.delete_Micrometre

# Register Micrometre in _imslib:
_imslib.Micrometre_swigregister(Micrometre)
class Millimetre(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, ticks=1.0):
        _imslib.Millimetre_swiginit(self, _imslib.new_Millimetre(ticks))

    def __float__(self):
        return _imslib.Millimetre___float__(self)

    def __str__(self):
        return _imslib.Millimetre___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec)

    value = property(_imslib.Millimetre_value_get, _imslib.Millimetre_value_set)
    __swig_destroy__ = _imslib.delete_Millimetre

# Register Millimetre in _imslib:
_imslib.Millimetre_swigregister(Millimetre)
class Centimetre(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, ticks=1.0):
        _imslib.Centimetre_swiginit(self, _imslib.new_Centimetre(ticks))

    def __float__(self):
        return _imslib.Centimetre___float__(self)

    def __str__(self):
        return _imslib.Centimetre___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec)

    value = property(_imslib.Centimetre_value_get, _imslib.Centimetre_value_set)
    __swig_destroy__ = _imslib.delete_Centimetre

# Register Centimetre in _imslib:
_imslib.Centimetre_swigregister(Centimetre)
class Decimetre(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, ticks=1.0):
        _imslib.Decimetre_swiginit(self, _imslib.new_Decimetre(ticks))

    def __float__(self):
        return _imslib.Decimetre___float__(self)

    def __str__(self):
        return _imslib.Decimetre___str__(self)

    def __format__(self, spec):
        val = float(self)
        return format(val, spec)

    value = property(_imslib.Decimetre_value_get, _imslib.Decimetre_value_set)
    __swig_destroy__ = _imslib.delete_Decimetre

# Register Decimetre in _imslib:
_imslib.Decimetre_swigregister(Decimetre)
Polarity_NORMAL = _imslib.Polarity_NORMAL
Polarity_INVERSE = _imslib.Polarity_INVERSE
class FWVersion(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    major = property(_imslib.FWVersion_major_get)
    minor = property(_imslib.FWVersion_minor_get)
    revision = property(_imslib.FWVersion_revision_get)

    def __str__(self):
        return _imslib.FWVersion___str__(self)

    def build_date_str(self):
        return _imslib.FWVersion_build_date_str(self)

    def __init__(self):
        _imslib.FWVersion_swiginit(self, _imslib.new_FWVersion())
    __swig_destroy__ = _imslib.delete_FWVersion

# Register FWVersion in _imslib:
_imslib.FWVersion_swigregister(FWVersion)
class IMSOption(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def Name(self):
        return _imslib.IMSOption_Name(self)

    def __init__(self):
        _imslib.IMSOption_swiginit(self, _imslib.new_IMSOption())
    __swig_destroy__ = _imslib.delete_IMSOption

# Register IMSOption in _imslib:
_imslib.IMSOption_swigregister(IMSOption)
class IMSControllerCapabilities(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    nSynthInterfaces = property(_imslib.IMSControllerCapabilities_nSynthInterfaces_get)
    FastImageTransfer = property(_imslib.IMSControllerCapabilities_FastImageTransfer_get)
    MaxImageSize = property(_imslib.IMSControllerCapabilities_MaxImageSize_get)
    SimultaneousPlayback = property(_imslib.IMSControllerCapabilities_SimultaneousPlayback_get)
    MaxImageRate = property(_imslib.IMSControllerCapabilities_MaxImageRate_get)
    RemoteUpgrade = property(_imslib.IMSControllerCapabilities_RemoteUpgrade_get)

    def __init__(self):
        _imslib.IMSControllerCapabilities_swiginit(self, _imslib.new_IMSControllerCapabilities())
    __swig_destroy__ = _imslib.delete_IMSControllerCapabilities

# Register IMSControllerCapabilities in _imslib:
_imslib.IMSControllerCapabilities_swigregister(IMSControllerCapabilities)
class IMSController(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def GetCap(self):
        return _imslib.IMSController_GetCap(self)

    def Description(self):
        return _imslib.IMSController_Description(self)

    def Model(self):
        return _imslib.IMSController_Model(self)

    def GetVersion(self):
        return _imslib.IMSController_GetVersion(self)

    def ImgTable(self):
        return _imslib.IMSController_ImgTable(self)

    def IsValid(self):
        return _imslib.IMSController_IsValid(self)

    def Interfaces(self):
        return _imslib.IMSController_Interfaces(self)

    def __init__(self):
        _imslib.IMSController_swiginit(self, _imslib.new_IMSController())
    __swig_destroy__ = _imslib.delete_IMSController

# Register IMSController in _imslib:
_imslib.IMSController_swigregister(IMSController)
class IMSSynthesiserCapabilities(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    lowerFrequency = property(_imslib.IMSSynthesiserCapabilities_lowerFrequency_get)
    upperFrequency = property(_imslib.IMSSynthesiserCapabilities_upperFrequency_get)
    freqBits = property(_imslib.IMSSynthesiserCapabilities_freqBits_get)
    amplBits = property(_imslib.IMSSynthesiserCapabilities_amplBits_get)
    phaseBits = property(_imslib.IMSSynthesiserCapabilities_phaseBits_get)
    LUTDepth = property(_imslib.IMSSynthesiserCapabilities_LUTDepth_get)
    LUTAmplBits = property(_imslib.IMSSynthesiserCapabilities_LUTAmplBits_get)
    LUTPhaseBits = property(_imslib.IMSSynthesiserCapabilities_LUTPhaseBits_get)
    LUTSyncABits = property(_imslib.IMSSynthesiserCapabilities_LUTSyncABits_get)
    LUTSyncDBits = property(_imslib.IMSSynthesiserCapabilities_LUTSyncDBits_get)
    sysClock = property(_imslib.IMSSynthesiserCapabilities_sysClock_get)
    syncClock = property(_imslib.IMSSynthesiserCapabilities_syncClock_get)
    channels = property(_imslib.IMSSynthesiserCapabilities_channels_get)
    RemoteUpgrade = property(_imslib.IMSSynthesiserCapabilities_RemoteUpgrade_get)
    ChannelComp = property(_imslib.IMSSynthesiserCapabilities_ChannelComp_get)

    def __init__(self):
        _imslib.IMSSynthesiserCapabilities_swiginit(self, _imslib.new_IMSSynthesiserCapabilities())
    __swig_destroy__ = _imslib.delete_IMSSynthesiserCapabilities

# Register IMSSynthesiserCapabilities in _imslib:
_imslib.IMSSynthesiserCapabilities_swigregister(IMSSynthesiserCapabilities)
class IMSSynthesiser(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def AddOn(self):
        return _imslib.IMSSynthesiser_AddOn(self)

    def GetCap(self):
        return _imslib.IMSSynthesiser_GetCap(self)

    def Description(self):
        return _imslib.IMSSynthesiser_Description(self)

    def Model(self):
        return _imslib.IMSSynthesiser_Model(self)

    def GetVersion(self):
        return _imslib.IMSSynthesiser_GetVersion(self)

    def IsValid(self):
        return _imslib.IMSSynthesiser_IsValid(self)

    def FST(self):
        return _imslib.IMSSynthesiser_FST(self)

    def __init__(self):
        _imslib.IMSSynthesiser_swiginit(self, _imslib.new_IMSSynthesiser())
    __swig_destroy__ = _imslib.delete_IMSSynthesiser

# Register IMSSynthesiser in _imslib:
_imslib.IMSSynthesiser_swigregister(IMSSynthesiser)
class CS_ETH(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.CS_ETH_swiginit(self, _imslib.new_CS_ETH(*args))
    __swig_destroy__ = _imslib.delete_CS_ETH

    def Ident(self):
        return _imslib.CS_ETH_Ident(self)
    dhcp = property(_imslib.CS_ETH_dhcp_get, _imslib.CS_ETH_dhcp_set)
    addr = property(_imslib.CS_ETH_addr_get, _imslib.CS_ETH_addr_set)
    mask = property(_imslib.CS_ETH_mask_get, _imslib.CS_ETH_mask_set)
    gw = property(_imslib.CS_ETH_gw_get, _imslib.CS_ETH_gw_set)

# Register CS_ETH in _imslib:
_imslib.CS_ETH_swigregister(CS_ETH)
class CS_RS422(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.CS_RS422_swiginit(self, _imslib.new_CS_RS422(*args))
    __swig_destroy__ = _imslib.delete_CS_RS422

    def Ident(self):
        return _imslib.CS_RS422_Ident(self)
    baud = property(_imslib.CS_RS422_baud_get, _imslib.CS_RS422_baud_set)

# Register CS_RS422 in _imslib:
_imslib.CS_RS422_swigregister(CS_RS422)
class IMSSystem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def Connect(self):
        return _imslib.IMSSystem_Connect(self)

    def Disconnect(self):
        return _imslib.IMSSystem_Disconnect(self)

    def SetTimeouts(self, send_timeout_ms, rx_timeout_ms, free_timeout_ms, discover_timeout_ms):
        return _imslib.IMSSystem_SetTimeouts(self, send_timeout_ms, rx_timeout_ms, free_timeout_ms, discover_timeout_ms)

    def Open(self):
        return _imslib.IMSSystem_Open(self)

    def Ctlr(self):
        return _imslib.IMSSystem_Ctlr(self)

    def Synth(self):
        return _imslib.IMSSystem_Synth(self)

    def ConnPort(self):
        return _imslib.IMSSystem_ConnPort(self)

    def __eq__(self, rhs):
        return _imslib.IMSSystem___eq__(self, rhs)

    def ApplySettings(self, settings):
        return _imslib.IMSSystem_ApplySettings(self, settings)

    def RetrieveSettings(self, settings):
        return _imslib.IMSSystem_RetrieveSettings(self, settings)

    def __init__(self):
        _imslib.IMSSystem_swiginit(self, _imslib.new_IMSSystem())
    __swig_destroy__ = _imslib.delete_IMSSystem

# Register IMSSystem in _imslib:
_imslib.IMSSystem_swigregister(IMSSystem)
class IMSList(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 _imslib.IMSList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _imslib.IMSList___nonzero__(self)

    def __bool__(self):
        return _imslib.IMSList___bool__(self)

    def __len__(self):
        return _imslib.IMSList___len__(self)

    def __getslice__(self, i, j):
        return _imslib.IMSList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _imslib.IMSList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _imslib.IMSList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _imslib.IMSList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _imslib.IMSList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _imslib.IMSList___setitem__(self, *args)

    def pop(self):
        return _imslib.IMSList_pop(self)

    def append(self, x):
        return _imslib.IMSList_append(self, x)

    def empty(self):
        return _imslib.IMSList_empty(self)

    def size(self):
        return _imslib.IMSList_size(self)

    def swap(self, v):
        return _imslib.IMSList_swap(self, v)

    def begin(self):
        return _imslib.IMSList_begin(self)

    def end(self):
        return _imslib.IMSList_end(self)

    def rbegin(self):
        return _imslib.IMSList_rbegin(self)

    def rend(self):
        return _imslib.IMSList_rend(self)

    def clear(self):
        return _imslib.IMSList_clear(self)

    def get_allocator(self):
        return _imslib.IMSList_get_allocator(self)

    def pop_back(self):
        return _imslib.IMSList_pop_back(self)

    def erase(self, *args):
        return _imslib.IMSList_erase(self, *args)

    def __init__(self, *args):
        _imslib.IMSList_swiginit(self, _imslib.new_IMSList(*args))

    def push_back(self, x):
        return _imslib.IMSList_push_back(self, x)

    def front(self):
        return _imslib.IMSList_front(self)

    def back(self):
        return _imslib.IMSList_back(self)

    def assign(self, n, x):
        return _imslib.IMSList_assign(self, n, x)

    def resize(self, *args):
        return _imslib.IMSList_resize(self, *args)

    def insert(self, *args):
        return _imslib.IMSList_insert(self, *args)

    def reserve(self, n):
        return _imslib.IMSList_reserve(self, n)

    def capacity(self):
        return _imslib.IMSList_capacity(self)
    __swig_destroy__ = _imslib.delete_IMSList

# Register IMSList in _imslib:
_imslib.IMSList_swigregister(IMSList)
class ConnectionConfig(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IncludeInScan = property(_imslib.ConnectionConfig_IncludeInScan_get, _imslib.ConnectionConfig_IncludeInScan_set)
    PortMask = property(_imslib.ConnectionConfig_PortMask_get, _imslib.ConnectionConfig_PortMask_set)

    def __init__(self, *args):
        _imslib.ConnectionConfig_swiginit(self, _imslib.new_ConnectionConfig(*args))
    __swig_destroy__ = _imslib.delete_ConnectionConfig

# Register ConnectionConfig in _imslib:
_imslib.ConnectionConfig_swigregister(ConnectionConfig)
class ConnectionList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def config(self, module):
        return _imslib.ConnectionList_config(self, module)

    def modules(self):
        return _imslib.ConnectionList_modules(self)

    def scan(self):
        return _imslib.ConnectionList_scan(self)

    def __init__(self):
        _imslib.ConnectionList_swiginit(self, _imslib.new_ConnectionList())
    __swig_destroy__ = _imslib.delete_ConnectionList

# Register ConnectionList in _imslib:
_imslib.ConnectionList_swigregister(ConnectionList)
class Crystal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Material_PbMoO4 = _imslib.Crystal_Material_PbMoO4
    Material_TeO2 = _imslib.Crystal_Material_TeO2
    Material_TeO2S = _imslib.Crystal_Material_TeO2S
    Material_aQuartz = _imslib.Crystal_Material_aQuartz
    Material_fSilica = _imslib.Crystal_Material_fSilica
    Material_fSilicaS = _imslib.Crystal_Material_fSilicaS
    Material_Ge = _imslib.Crystal_Material_Ge

    def __init__(self, *args):
        _imslib.Crystal_swiginit(self, _imslib.new_Crystal(*args))

    def RefractiveIndex(self, wavelength):
        return _imslib.Crystal_RefractiveIndex(self, wavelength)

    def BraggAngle(self, wavelength, frequency):
        return _imslib.Crystal_BraggAngle(self, wavelength, frequency)
    Type = property(_imslib.Crystal_Type_get)
    Description = property(_imslib.Crystal_Description_get)
    AcousticVelocity = property(_imslib.Crystal_AcousticVelocity_get)
    __swig_destroy__ = _imslib.delete_Crystal

# Register Crystal in _imslib:
_imslib.Crystal_swigregister(Crystal)
class AODevice(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.AODevice_swiginit(self, _imslib.new_AODevice(*args))

    def ExternalBragg(self, *args):
        return _imslib.AODevice_ExternalBragg(self, *args)

    def GetCompensationFunction(self, *args):
        return _imslib.AODevice_GetCompensationFunction(self, *args)
    Model = property(_imslib.AODevice_Model_get)
    Material = property(_imslib.AODevice_Material_get)
    CentreFrequency = property(_imslib.AODevice_CentreFrequency_get)
    SweepBW = property(_imslib.AODevice_SweepBW_get)
    OperatingWavelength = property(_imslib.AODevice_OperatingWavelength_get)
    GeomConstant = property(_imslib.AODevice_GeomConstant_get)
    __swig_destroy__ = _imslib.delete_AODevice

# Register AODevice in _imslib:
_imslib.AODevice_swigregister(AODevice)
class AODeviceList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def GetList():
        return _imslib.AODeviceList_GetList()

# Register AODeviceList in _imslib:
_imslib.AODeviceList_swigregister(AODeviceList)
class ImagePoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __str__(self):
        return _imslib.ImagePoint___str__(self)

    def __eq__(self, rhs):
        return _imslib.ImagePoint___eq__(self, rhs)

    def GetFAP(self, arg2):
        return _imslib.ImagePoint_GetFAP(self, arg2)

    def SetFAP(self, arg2, arg3):
        return _imslib.ImagePoint_SetFAP(self, arg2, arg3)

    def SetAll(self, arg2):
        return _imslib.ImagePoint_SetAll(self, arg2)

    def GetSyncA(self, index):
        return _imslib.ImagePoint_GetSyncA(self, index)

    def SetSyncA(self, index, value):
        return _imslib.ImagePoint_SetSyncA(self, index, value)
    SyncD = property(_imslib.ImagePoint_SyncD_get, _imslib.ImagePoint_SyncD_set)
    SyncA1 = property(_imslib.ImagePoint_SyncA1_get, _imslib.ImagePoint_SyncA1_set)
    SyncA2 = property(_imslib.ImagePoint_SyncA2_get, _imslib.ImagePoint_SyncA2_set)
    FreqCh1 = property(_imslib.ImagePoint_FreqCh1_get, _imslib.ImagePoint_FreqCh1_set)
    AmplCh1 = property(_imslib.ImagePoint_AmplCh1_get, _imslib.ImagePoint_AmplCh1_set)
    PhaseCh1 = property(_imslib.ImagePoint_PhaseCh1_get, _imslib.ImagePoint_PhaseCh1_set)
    FreqCh2 = property(_imslib.ImagePoint_FreqCh2_get, _imslib.ImagePoint_FreqCh2_set)
    AmplCh2 = property(_imslib.ImagePoint_AmplCh2_get, _imslib.ImagePoint_AmplCh2_set)
    PhaseCh2 = property(_imslib.ImagePoint_PhaseCh2_get, _imslib.ImagePoint_PhaseCh2_set)
    FreqCh3 = property(_imslib.ImagePoint_FreqCh3_get, _imslib.ImagePoint_FreqCh3_set)
    AmplCh3 = property(_imslib.ImagePoint_AmplCh3_get, _imslib.ImagePoint_AmplCh3_set)
    PhaseCh3 = property(_imslib.ImagePoint_PhaseCh3_get, _imslib.ImagePoint_PhaseCh3_set)
    FreqCh4 = property(_imslib.ImagePoint_FreqCh4_get, _imslib.ImagePoint_FreqCh4_set)
    AmplCh4 = property(_imslib.ImagePoint_AmplCh4_get, _imslib.ImagePoint_AmplCh4_set)
    PhaseCh4 = property(_imslib.ImagePoint_PhaseCh4_get, _imslib.ImagePoint_PhaseCh4_set)

    def __init__(self, *args):
        _imslib.ImagePoint_swiginit(self, _imslib.new_ImagePoint(*args))
    __swig_destroy__ = _imslib.delete_ImagePoint

# Register ImagePoint in _imslib:
_imslib.ImagePoint_swigregister(ImagePoint)
class Image(DequeBase_ImagePoint):
    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):
        _imslib.Image_swiginit(self, _imslib.new_Image(*args))

    def __str__(self):
        return _imslib.Image___str__(self)
    ClockRate = property(_imslib.Image_ClockRate_get, _imslib.Image_ClockRate_set)
    ExtClockDivide = property(_imslib.Image_ExtClockDivide_get, _imslib.Image_ExtClockDivide_set)
    Description = property(_imslib.Image_Description_get, _imslib.Image_Description_set)
    __swig_destroy__ = _imslib.delete_Image

# Register Image in _imslib:
_imslib.Image_swigregister(Image)
class ImageTableEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __str__(self):
        return _imslib.ImageTableEntry___str__(self)

    def __init__(self, *args):
        _imslib.ImageTableEntry_swiginit(self, _imslib.new_ImageTableEntry(*args))

    def Matches(self, img):
        return _imslib.ImageTableEntry_Matches(self, img)
    Handle = property(_imslib.ImageTableEntry_Handle_get)
    Address = property(_imslib.ImageTableEntry_Address_get)
    NPts = property(_imslib.ImageTableEntry_NPts_get)
    Size = property(_imslib.ImageTableEntry_Size_get)
    Format = property(_imslib.ImageTableEntry_Format_get)
    GetUUID = property(_imslib.ImageTableEntry_GetUUID_get)
    Name = property(_imslib.ImageTableEntry_Name_get)
    __swig_destroy__ = _imslib.delete_ImageTableEntry

# Register ImageTableEntry in _imslib:
_imslib.ImageTableEntry_swigregister(ImageTableEntry)
ImageRepeats_NONE = _imslib.ImageRepeats_NONE
ImageRepeats_PROGRAM = _imslib.ImageRepeats_PROGRAM
ImageRepeats_FOREVER = _imslib.ImageRepeats_FOREVER
SequenceTermAction_DISCARD = _imslib.SequenceTermAction_DISCARD
SequenceTermAction_RECYCLE = _imslib.SequenceTermAction_RECYCLE
SequenceTermAction_STOP_DISCARD = _imslib.SequenceTermAction_STOP_DISCARD
SequenceTermAction_STOP_RECYCLE = _imslib.SequenceTermAction_STOP_RECYCLE
SequenceTermAction_REPEAT = _imslib.SequenceTermAction_REPEAT
SequenceTermAction_REPEAT_FROM = _imslib.SequenceTermAction_REPEAT_FROM
SequenceTermAction_INSERT = _imslib.SequenceTermAction_INSERT
SequenceTermAction_STOP_INSERT = _imslib.SequenceTermAction_STOP_INSERT
class SequenceEntry(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

    def __eq__(self, rhs):
        return _imslib.SequenceEntry___eq__(self, rhs)

    def SetFrequencyOffset(self, *args):
        return _imslib.SequenceEntry_SetFrequencyOffset(self, *args)

    def GetFrequencyOffset(self, chan):
        return _imslib.SequenceEntry_GetFrequencyOffset(self, chan)
    SyncOutDelay = property(_imslib.SequenceEntry_SyncOutDelay_get, _imslib.SequenceEntry_SyncOutDelay_set)
    UUID = property(_imslib.SequenceEntry_UUID_get)
    NumRpts = property(_imslib.SequenceEntry_NumRpts_get)
    __swig_destroy__ = _imslib.delete_SequenceEntry

# Register SequenceEntry in _imslib:
_imslib.SequenceEntry_swigregister(SequenceEntry)
class ImageSequenceEntry(SequenceEntry):
    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):
        _imslib.ImageSequenceEntry_swiginit(self, _imslib.new_ImageSequenceEntry(*args))

    def __eq__(self, rhs):
        return _imslib.ImageSequenceEntry___eq__(self, rhs)
    PostImgDelay = property(_imslib.ImageSequenceEntry_PostImgDelay_get, _imslib.ImageSequenceEntry_PostImgDelay_set)
    ExtDiv = property(_imslib.ImageSequenceEntry_ExtDiv_get)
    IntOsc = property(_imslib.ImageSequenceEntry_IntOsc_get)
    RptType = property(_imslib.ImageSequenceEntry_RptType_get)
    __swig_destroy__ = _imslib.delete_ImageSequenceEntry

# Register ImageSequenceEntry in _imslib:
_imslib.ImageSequenceEntry_swigregister(ImageSequenceEntry)
class ImageSequence(ListBase_SequenceEntry):
    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):
        _imslib.ImageSequence_swiginit(self, _imslib.new_ImageSequence(*args))

    def OnTermination(self, *args):
        return _imslib.ImageSequence_OnTermination(self, *args)

    def TermInsertBefore(self):
        return _imslib.ImageSequence_TermInsertBefore(self)
    TermAction = property(_imslib.ImageSequence_TermAction_get)
    TermValue = property(_imslib.ImageSequence_TermValue_get)
    __swig_destroy__ = _imslib.delete_ImageSequence

# Register ImageSequence in _imslib:
_imslib.ImageSequence_swigregister(ImageSequence)
class ImageGroup(DequeBase_Image):
    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):
        _imslib.ImageGroup_swiginit(self, _imslib.new_ImageGroup(*args))

    def __str__(self):
        return _imslib.ImageGroup___str__(self)

    def Size(self):
        return _imslib.ImageGroup_Size(self)
    Author = property(_imslib.ImageGroup_Author_get, _imslib.ImageGroup_Author_set)
    Company = property(_imslib.ImageGroup_Company_get, _imslib.ImageGroup_Company_set)
    Revision = property(_imslib.ImageGroup_Revision_get, _imslib.ImageGroup_Revision_set)
    Description = property(_imslib.ImageGroup_Description_get, _imslib.ImageGroup_Description_set)
    CreatedTimeFormat = property(_imslib.ImageGroup_CreatedTimeFormat_get)
    Sequence = property(_imslib.ImageGroup_Sequence_get, _imslib.ImageGroup_Sequence_set)
    __swig_destroy__ = _imslib.delete_ImageGroup

# Register ImageGroup in _imslib:
_imslib.ImageGroup_swigregister(ImageGroup)
class DownloadEvents(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):
        _imslib.DownloadEvents_swiginit(self, _imslib.new_DownloadEvents())
    __swig_destroy__ = _imslib.delete_DownloadEvents

# Register DownloadEvents in _imslib:
_imslib.DownloadEvents_swigregister(DownloadEvents)
class ImageDownload(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, ims, img):
        _imslib.ImageDownload_swiginit(self, _imslib.new_ImageDownload(ims, img))

    def SetFormat(self, fmt):
        return _imslib.ImageDownload_SetFormat(self, fmt)

    def StartDownload(self):
        return _imslib.ImageDownload_StartDownload(self)

    def StartVerify(self):
        return _imslib.ImageDownload_StartVerify(self)

    def GetVerifyError(self):
        return _imslib.ImageDownload_GetVerifyError(self)

    def ImageDownloadEventSubscribe(self, message, handler):
        return _imslib.ImageDownload_ImageDownloadEventSubscribe(self, message, handler)

    def ImageDownloadEventUnsubscribe(self, message, handler):
        return _imslib.ImageDownload_ImageDownloadEventUnsubscribe(self, message, handler)
    __swig_destroy__ = _imslib.delete_ImageDownload

# Register ImageDownload in _imslib:
_imslib.ImageDownload_swigregister(ImageDownload)
class ImagePlayerEvents(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):
        _imslib.ImagePlayerEvents_swiginit(self, _imslib.new_ImagePlayerEvents())
    __swig_destroy__ = _imslib.delete_ImagePlayerEvents

# Register ImagePlayerEvents in _imslib:
_imslib.ImagePlayerEvents_swigregister(ImagePlayerEvents)

import enum

class PointClock(enum.IntEnum):
    INTERNAL = 0
    EXTERNAL = 1

class ImageTrigger(enum.IntEnum):
    POST_DELAY = 0
    EXTERNAL = 1
    HOST = 2
    CONTINUOUS = 3

class StopStyle(enum.IntEnum):
    GRACEFULLY = 0
    IMMEDIATELY = 1

class ImagePlayerConfiguration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rpts = property(_imslib.ImagePlayerConfiguration_rpts_get, _imslib.ImagePlayerConfiguration_rpts_set)
    n_rpts = property(_imslib.ImagePlayerConfiguration_n_rpts_get, _imslib.ImagePlayerConfiguration_n_rpts_set)
    clk_pol = property(_imslib.ImagePlayerConfiguration_clk_pol_get, _imslib.ImagePlayerConfiguration_clk_pol_set)
    trig_pol = property(_imslib.ImagePlayerConfiguration_trig_pol_get, _imslib.ImagePlayerConfiguration_trig_pol_set)
    delay = property(_imslib.ImagePlayerConfiguration_delay_get, _imslib.ImagePlayerConfiguration_delay_set)

    def get_int_ext(self):
        return _imslib.ImagePlayerConfiguration_get_int_ext(self)

    def set_int_ext(self, clk):
        return _imslib.ImagePlayerConfiguration_set_int_ext(self, clk)

    def get_trig(self):
        return _imslib.ImagePlayerConfiguration_get_trig(self)

    def set_trig(self, trig_):
        return _imslib.ImagePlayerConfiguration_set_trig(self, trig_)

    def __init__(self, *args):
        _imslib.ImagePlayerConfiguration_swiginit(self, _imslib.new_ImagePlayerConfiguration(*args))

    Clock = property(get_int_ext, set_int_ext)
    Trig = property(get_trig, set_trig)

    __swig_destroy__ = _imslib.delete_ImagePlayerConfiguration

# Register ImagePlayerConfiguration in _imslib:
_imslib.ImagePlayerConfiguration_swigregister(ImagePlayerConfiguration)
class ImagePlayer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.ImagePlayer_swiginit(self, _imslib.new_ImagePlayer(*args))

    def Play(self, *args):
        return _imslib.ImagePlayer_Play(self, *args)

    def GetProgress(self):
        return _imslib.ImagePlayer_GetProgress(self)

    def Stop(self, *args):
        return _imslib.ImagePlayer_Stop(self, *args)

    def SetPostDelay(self, dly):
        return _imslib.ImagePlayer_SetPostDelay(self, dly)

    def ImagePlayerEventSubscribe(self, message, handler):
        return _imslib.ImagePlayer_ImagePlayerEventSubscribe(self, message, handler)

    def ImagePlayerEventUnsubscribe(self, message, handler):
        return _imslib.ImagePlayer_ImagePlayerEventUnsubscribe(self, message, handler)

    def get_cfg(self):
        return _imslib.ImagePlayer_get_cfg(self)

    def set_cfg(self, py):
        return _imslib.ImagePlayer_set_cfg(self, py)

    Config = property(get_cfg, set_cfg)

    __swig_destroy__ = _imslib.delete_ImagePlayer

# Register ImagePlayer in _imslib:
_imslib.ImagePlayer_swigregister(ImagePlayer)
class ImageTableViewer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __getitem__(self, i):
        return _imslib.ImageTableViewer___getitem__(self, i)

    def __len__(self):
        return _imslib.ImageTableViewer___len__(self)

    def __bool__(self):
        return _imslib.ImageTableViewer___bool__(self)

    def __str__(self):
        result = ""
        for i in range(len(self)):
            result += str(self[i])
        return result

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]


    def __init__(self, ims):
        _imslib.ImageTableViewer_swiginit(self, _imslib.new_ImageTableViewer(ims))

    def Entries(self):
        return _imslib.ImageTableViewer_Entries(self)

    def Erase(self, *args):
        return _imslib.ImageTableViewer_Erase(self, *args)

    def Clear(self):
        return _imslib.ImageTableViewer_Clear(self)
    __swig_destroy__ = _imslib.delete_ImageTableViewer

# Register ImageTableViewer in _imslib:
_imslib.ImageTableViewer_swigregister(ImageTableViewer)
CompensationEvents_RX_DDS_POWER = _imslib.CompensationEvents_RX_DDS_POWER
CompensationEvents_DOWNLOAD_FINISHED = _imslib.CompensationEvents_DOWNLOAD_FINISHED
CompensationEvents_DOWNLOAD_ERROR = _imslib.CompensationEvents_DOWNLOAD_ERROR
CompensationEvents_VERIFY_SUCCESS = _imslib.CompensationEvents_VERIFY_SUCCESS
CompensationEvents_VERIFY_FAIL = _imslib.CompensationEvents_VERIFY_FAIL
CompensationFeature_AMPLITUDE = _imslib.CompensationFeature_AMPLITUDE
CompensationFeature_PHASE = _imslib.CompensationFeature_PHASE
CompensationFeature_SYNC_DIG = _imslib.CompensationFeature_SYNC_DIG
CompensationFeature_SYNC_ANLG = _imslib.CompensationFeature_SYNC_ANLG
CompensationModifier_REPLACE = _imslib.CompensationModifier_REPLACE
CompensationModifier_MULTIPLY = _imslib.CompensationModifier_MULTIPLY
class CompensationPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.CompensationPoint_swiginit(self, _imslib.new_CompensationPoint(*args))
    Amplitude = property(_imslib.CompensationPoint_Amplitude_get, _imslib.CompensationPoint_Amplitude_set)
    Phase = property(_imslib.CompensationPoint_Phase_get, _imslib.CompensationPoint_Phase_set)
    SyncDig = property(_imslib.CompensationPoint_SyncDig_get, _imslib.CompensationPoint_SyncDig_set)
    SyncAnlg = property(_imslib.CompensationPoint_SyncAnlg_get, _imslib.CompensationPoint_SyncAnlg_set)
    __swig_destroy__ = _imslib.delete_CompensationPoint

# Register CompensationPoint in _imslib:
_imslib.CompensationPoint_swigregister(CompensationPoint)
class CompensationPointSpecification(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.CompensationPointSpecification_swiginit(self, _imslib.new_CompensationPointSpecification(*args))
    Freq = property(_imslib.CompensationPointSpecification_Freq_get, _imslib.CompensationPointSpecification_Freq_set)
    Spec = property(_imslib.CompensationPointSpecification_Spec_get)
    __swig_destroy__ = _imslib.delete_CompensationPointSpecification

# Register CompensationPointSpecification in _imslib:
_imslib.CompensationPointSpecification_swigregister(CompensationPointSpecification)
class CompensationFunction(ListBase_CompensationPointSpecification):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    InterpolationStyle_SPOT = _imslib.CompensationFunction_InterpolationStyle_SPOT
    InterpolationStyle_STEP = _imslib.CompensationFunction_InterpolationStyle_STEP
    InterpolationStyle_LINEAR = _imslib.CompensationFunction_InterpolationStyle_LINEAR
    InterpolationStyle_LINEXTEND = _imslib.CompensationFunction_InterpolationStyle_LINEXTEND
    InterpolationStyle_BSPLINE = _imslib.CompensationFunction_InterpolationStyle_BSPLINE

    def __init__(self, *args):
        _imslib.CompensationFunction_swiginit(self, _imslib.new_CompensationFunction(*args))
    AmplitudeInterpolationStyle = property(_imslib.CompensationFunction_AmplitudeInterpolationStyle_get, _imslib.CompensationFunction_AmplitudeInterpolationStyle_set)
    PhaseInterpolationStyle = property(_imslib.CompensationFunction_PhaseInterpolationStyle_get, _imslib.CompensationFunction_PhaseInterpolationStyle_set)
    SyncAnlgInterpolationStyle = property(_imslib.CompensationFunction_SyncAnlgInterpolationStyle_get, _imslib.CompensationFunction_SyncAnlgInterpolationStyle_set)
    SyncDigInterpolationStyle = property(_imslib.CompensationFunction_SyncDigInterpolationStyle_get, _imslib.CompensationFunction_SyncDigInterpolationStyle_set)
    __swig_destroy__ = _imslib.delete_CompensationFunction

# Register CompensationFunction in _imslib:
_imslib.CompensationFunction_swigregister(CompensationFunction)
class CompensationTable(DequeBase_CompensationPoint):
    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):
        _imslib.CompensationTable_swiginit(self, _imslib.new_CompensationTable(*args))

    def assign(self, arg2):
        return _imslib.CompensationTable_assign(self, arg2)

    def ApplyFunction(self, *args):
        return _imslib.CompensationTable_ApplyFunction(self, *args)

    def Size(self):
        return _imslib.CompensationTable_Size(self)

    def FrequencyAt(self, index):
        return _imslib.CompensationTable_FrequencyAt(self, index)

    def Save(self, fileName):
        return _imslib.CompensationTable_Save(self, fileName)
    Upper = property(_imslib.CompensationTable_Upper_get)
    Lower = property(_imslib.CompensationTable_Lower_get)
    __swig_destroy__ = _imslib.delete_CompensationTable

# Register CompensationTable in _imslib:
_imslib.CompensationTable_swigregister(CompensationTable)
class CompensationTableExporter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.CompensationTableExporter_swiginit(self, _imslib.new_CompensationTableExporter(*args))

    def ProvideGlobalTable(self, tbl):
        return _imslib.CompensationTableExporter_ProvideGlobalTable(self, tbl)

    def ProvideChannelTable(self, chan, tbl):
        return _imslib.CompensationTableExporter_ProvideChannelTable(self, chan, tbl)

    def ExportGlobalLUT(self, fileName):
        return _imslib.CompensationTableExporter_ExportGlobalLUT(self, fileName)

    def ExportChannelLUT(self, fileName):
        return _imslib.CompensationTableExporter_ExportChannelLUT(self, fileName)
    __swig_destroy__ = _imslib.delete_CompensationTableExporter

# Register CompensationTableExporter in _imslib:
_imslib.CompensationTableExporter_swigregister(CompensationTableExporter)
class CompensationTableImporter(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, fileName):
        _imslib.CompensationTableImporter_swiginit(self, _imslib.new_CompensationTableImporter(fileName))

    def IsValid(self):
        return _imslib.CompensationTableImporter_IsValid(self)

    def IsGlobal(self):
        return _imslib.CompensationTableImporter_IsGlobal(self)

    def Channels(self):
        return _imslib.CompensationTableImporter_Channels(self)

    def RetrieveGlobalLUT(self):
        return _imslib.CompensationTableImporter_RetrieveGlobalLUT(self)

    def RetrieveChannelLUT(self, chan):
        return _imslib.CompensationTableImporter_RetrieveChannelLUT(self, chan)
    Size = property(_imslib.CompensationTableImporter_Size_get)
    LowerFrequency = property(_imslib.CompensationTableImporter_LowerFrequency_get)
    UpperFrequency = property(_imslib.CompensationTableImporter_UpperFrequency_get)
    __swig_destroy__ = _imslib.delete_CompensationTableImporter

# Register CompensationTableImporter in _imslib:
_imslib.CompensationTableImporter_swigregister(CompensationTableImporter)
class CompensationTableDownload(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, ims, tbl):
        _imslib.CompensationTableDownload_swiginit(self, _imslib.new_CompensationTableDownload(ims, tbl))

    def StartDownload(self):
        return _imslib.CompensationTableDownload_StartDownload(self)

    def StartVerify(self):
        return _imslib.CompensationTableDownload_StartVerify(self)

    def GetVerifyError(self):
        return _imslib.CompensationTableDownload_GetVerifyError(self)

    def CompensationTableDownloadEventSubscribe(self, message, handler):
        return _imslib.CompensationTableDownload_CompensationTableDownloadEventSubscribe(self, message, handler)

    def CompensationTableDownloadEventUnsubscribe(self, message, handler):
        return _imslib.CompensationTableDownload_CompensationTableDownloadEventUnsubscribe(self, message, handler)

    def Store(self, _def, FileName):
        return _imslib.CompensationTableDownload_Store(self, _def, FileName)
    __swig_destroy__ = _imslib.delete_CompensationTableDownload

# Register CompensationTableDownload in _imslib:
_imslib.CompensationTableDownload_swigregister(CompensationTableDownload)
class ImageGroupList(ListBase_ImageGroup):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _imslib.ImageGroupList_swiginit(self, _imslib.new_ImageGroupList())
    __swig_destroy__ = _imslib.delete_ImageGroupList

# Register ImageGroupList in _imslib:
_imslib.ImageGroupList_swigregister(ImageGroupList)
class CompensationFunctionList(ListBase_CompensationFunction):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _imslib.CompensationFunctionList_swiginit(self, _imslib.new_CompensationFunctionList())
    __swig_destroy__ = _imslib.delete_CompensationFunctionList

# Register CompensationFunctionList in _imslib:
_imslib.CompensationFunctionList_swigregister(CompensationFunctionList)
class ToneBufferList(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):
        _imslib.ToneBufferList_swiginit(self, _imslib.new_ToneBufferList())
    __swig_destroy__ = _imslib.delete_ToneBufferList

# Register ToneBufferList in _imslib:
_imslib.ToneBufferList_swigregister(ToneBufferList)
class ImageProject(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _imslib.ImageProject_swiginit(self, _imslib.new_ImageProject(*args))

    def Clear(self):
        return _imslib.ImageProject_Clear(self)

    def Save(self, fileName):
        return _imslib.ImageProject_Save(self, fileName)

    def Load(self, fileName):
        return _imslib.ImageProject_Load(self, fileName)
    ImageGroupContainer = property(_imslib.ImageProject_ImageGroupContainer_get, _imslib.ImageProject_ImageGroupContainer_set)
    CompensationFunctionContainer = property(_imslib.ImageProject_CompensationFunctionContainer_get, _imslib.ImageProject_CompensationFunctionContainer_set)
    ToneBufferContainer = property(_imslib.ImageProject_ToneBufferContainer_get, _imslib.ImageProject_ToneBufferContainer_set)
    FreeImageContainer = property(_imslib.ImageProject_FreeImageContainer_get, _imslib.ImageProject_FreeImageContainer_set)
    __swig_destroy__ = _imslib.delete_ImageProject

# Register ImageProject in _imslib:
_imslib.ImageProject_swigregister(ImageProject)
SignalPathEvents_RX_DDS_POWER = _imslib.SignalPathEvents_RX_DDS_POWER
SignalPathEvents_ENC_VEL_CH_X = _imslib.SignalPathEvents_ENC_VEL_CH_X
SignalPathEvents_ENC_VEL_CH_Y = _imslib.SignalPathEvents_ENC_VEL_CH_Y
class SignalPath(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AmplitudeControl_OFF = _imslib.SignalPath_AmplitudeControl_OFF
    AmplitudeControl_EXTERNAL = _imslib.SignalPath_AmplitudeControl_EXTERNAL
    AmplitudeControl_WIPER_1 = _imslib.SignalPath_AmplitudeControl_WIPER_1
    AmplitudeControl_WIPER_2 = _imslib.SignalPath_AmplitudeControl_WIPER_2
    AmplitudeControl_INDEPENDENT = _imslib.SignalPath_AmplitudeControl_INDEPENDENT
    ToneBufferControl_HOST = _imslib.SignalPath_ToneBufferControl_HOST
    ToneBufferControl_EXTERNAL = _imslib.SignalPath_ToneBufferControl_EXTERNAL
    ToneBufferControl_EXTERNAL_EXTENDED = _imslib.SignalPath_ToneBufferControl_EXTERNAL_EXTENDED
    ToneBufferControl_OFF = _imslib.SignalPath_ToneBufferControl_OFF
    Compensation_ACTIVE = _imslib.SignalPath_Compensation_ACTIVE
    Compensation_BYPASS = _imslib.SignalPath_Compensation_BYPASS
    SYNC_SRC_FREQUENCY_CH1 = _imslib.SignalPath_SYNC_SRC_FREQUENCY_CH1
    SYNC_SRC_FREQUENCY_CH2 = _imslib.SignalPath_SYNC_SRC_FREQUENCY_CH2
    SYNC_SRC_FREQUENCY_CH3 = _imslib.SignalPath_SYNC_SRC_FREQUENCY_CH3
    SYNC_SRC_FREQUENCY_CH4 = _imslib.SignalPath_SYNC_SRC_FREQUENCY_CH4
    SYNC_SRC_AMPLITUDE_CH1 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_CH1
    SYNC_SRC_AMPLITUDE_CH2 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_CH2
    SYNC_SRC_AMPLITUDE_CH3 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_CH3
    SYNC_SRC_AMPLITUDE_CH4 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_CH4
    SYNC_SRC_AMPLITUDE_PRE_COMP_CH1 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_PRE_COMP_CH1
    SYNC_SRC_AMPLITUDE_PRE_COMP_CH2 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_PRE_COMP_CH2
    SYNC_SRC_AMPLITUDE_PRE_COMP_CH3 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_PRE_COMP_CH3
    SYNC_SRC_AMPLITUDE_PRE_COMP_CH4 = _imslib.SignalPath_SYNC_SRC_AMPLITUDE_PRE_COMP_CH4
    SYNC_SRC_PHASE_CH1 = _imslib.SignalPath_SYNC_SRC_PHASE_CH1
    SYNC_SRC_PHASE_CH2 = _imslib.SignalPath_SYNC_SRC_PHASE_CH2
    SYNC_SRC_PHASE_CH3 = _imslib.SignalPath_SYNC_SRC_PHASE_CH3
    SYNC_SRC_PHASE_CH4 = _imslib.SignalPath_SYNC_SRC_PHASE_CH4
    SYNC_SRC_LOOKUP_FIELD_CH1 = _imslib.SignalPath_SYNC_SRC_LOOKUP_FIELD_CH1
    SYNC_SRC_LOOKUP_FIELD_CH2 = _imslib.SignalPath_SYNC_SRC_LOOKUP_FIELD_CH2
    SYNC_SRC_LOOKUP_FIELD_CH3 = _imslib.SignalPath_SYNC_SRC_LOOKUP_FIELD_CH3
    SYNC_SRC_LOOKUP_FIELD_CH4 = _imslib.SignalPath_SYNC_SRC_LOOKUP_FIELD_CH4
    SYNC_SRC_IMAGE_ANLG_A = _imslib.SignalPath_SYNC_SRC_IMAGE_ANLG_A
    SYNC_SRC_IMAGE_ANLG_B = _imslib.SignalPath_SYNC_SRC_IMAGE_ANLG_B
    SYNC_SRC_IMAGE_DIG = _imslib.SignalPath_SYNC_SRC_IMAGE_DIG
    SYNC_SINK_ANLG_A = _imslib.SignalPath_SYNC_SINK_ANLG_A
    SYNC_SINK_ANLG_B = _imslib.SignalPath_SYNC_SINK_ANLG_B
    SYNC_SINK_DIG = _imslib.SignalPath_SYNC_SINK_DIG
    SYNC_DIG_MODE_PULSE = _imslib.SignalPath_SYNC_DIG_MODE_PULSE
    SYNC_DIG_MODE_LEVEL = _imslib.SignalPath_SYNC_DIG_MODE_LEVEL
    ENCODER_MODE_QUADRATURE = _imslib.SignalPath_ENCODER_MODE_QUADRATURE
    ENCODER_MODE_COUNT_DIRECTION = _imslib.SignalPath_ENCODER_MODE_COUNT_DIRECTION
    VELOCITY_MODE_FAST = _imslib.SignalPath_VELOCITY_MODE_FAST
    VELOCITY_MODE_SLOW = _imslib.SignalPath_VELOCITY_MODE_SLOW
    ENCODER_CHANNEL_CH_X = _imslib.SignalPath_ENCODER_CHANNEL_CH_X
    ENCODER_CHANNEL_CH_Y = _imslib.SignalPath_ENCODER_CHANNEL_CH_Y

    def __init__(self, ims):
        _imslib.SignalPath_swiginit(self, _imslib.new_SignalPath(ims))

    def UpdateDDSPowerLevel(self, power):
        return _imslib.SignalPath_UpdateDDSPowerLevel(self, power)

    def UpdateRFAmplitude(self, *args):
        return _imslib.SignalPath_UpdateRFAmplitude(self, *args)

    def SwitchRFAmplitudeControlSource(self, *args):
        return _imslib.SignalPath_SwitchRFAmplitudeControlSource(self, *args)

    def UpdatePhaseTuning(self, channel, phase):
        return _imslib.SignalPath_UpdatePhaseTuning(self, channel, phase)

    def SetChannelReversal(self, reversal):
        return _imslib.SignalPath_SetChannelReversal(self, reversal)

    def EnableImagePathCompensation(self, amplComp, phaseComp):
        return _imslib.SignalPath_EnableImagePathCompensation(self, amplComp, phaseComp)

    def EnableXYPhaseCompensation(self, XYCompEnable):
        return _imslib.SignalPath_EnableXYPhaseCompensation(self, XYCompEnable)

    def SetXYChannelDelay(self, delay):
        return _imslib.SignalPath_SetXYChannelDelay(self, delay)

    def SetChannelDelay(self, first, second):
        return _imslib.SignalPath_SetChannelDelay(self, first, second)

    def SetCalibrationTone(self, fap):
        return _imslib.SignalPath_SetCalibrationTone(self, fap)

    def ClearTone(self):
        return _imslib.SignalPath_ClearTone(self)

    def SetCalibrationChannelLock(self, chan):
        return _imslib.SignalPath_SetCalibrationChannelLock(self, chan)

    def ClearCalibrationChannelLock(self, *args):
        return _imslib.SignalPath_ClearCalibrationChannelLock(self, *args)

    def GetCalibrationChannelLockState(self, chan):
        return _imslib.SignalPath_GetCalibrationChannelLockState(self, chan)

    def PhaseResync(self):
        return _imslib.SignalPath_PhaseResync(self)

    def AutoPhaseResync(self, enable=True):
        return _imslib.SignalPath_AutoPhaseResync(self, enable)

    def SetEnhancedToneMode(self, tone_ch1, tone_ch2, tone_ch3, tone_ch4):
        return _imslib.SignalPath_SetEnhancedToneMode(self, tone_ch1, tone_ch2, tone_ch3, tone_ch4)

    def SetEnhancedToneChannel(self, chan, tone):
        return _imslib.SignalPath_SetEnhancedToneChannel(self, chan, tone)

    def ClearEnhancedToneMode(self):
        return _imslib.SignalPath_ClearEnhancedToneMode(self)

    def ClearEnhancedToneChannel(self, chan):
        return _imslib.SignalPath_ClearEnhancedToneChannel(self, chan)

    def AssignSynchronousOutput(self, sink, src):
        return _imslib.SignalPath_AssignSynchronousOutput(self, sink, src)

    def ConfigureSyncDigitalOutput(self, delay, pulse_length):
        return _imslib.SignalPath_ConfigureSyncDigitalOutput(self, delay, pulse_length)

    def SyncDigitalOutputInvert(self, invert):
        return _imslib.SignalPath_SyncDigitalOutputInvert(self, invert)

    def SyncDigitalOutputMode(self, mode, index):
        return _imslib.SignalPath_SyncDigitalOutputMode(self, mode, index)

    def UpdateLocalToneBuffer(self, *args):
        return _imslib.SignalPath_UpdateLocalToneBuffer(self, *args)

    def UpdateEncoder(self, velcomp):
        return _imslib.SignalPath_UpdateEncoder(self, velcomp)

    def DisableEncoder(self):
        return _imslib.SignalPath_DisableEncoder(self)

    def ReportEncoderVelocity(self, chan):
        return _imslib.SignalPath_ReportEncoderVelocity(self, chan)

    def AddFrequencyOffset(self, *args):
        return _imslib.SignalPath_AddFrequencyOffset(self, *args)

    def SubtractFrequencyOffset(self, *args):
        return _imslib.SignalPath_SubtractFrequencyOffset(self, *args)

    def SignalPathEventSubscribe(self, message, handler):
        return _imslib.SignalPath_SignalPathEventSubscribe(self, message, handler)

    def SignalPathEventUnsubscribe(self, message, handler):
        return _imslib.SignalPath_SignalPathEventUnsubscribe(self, message, handler)
    __swig_destroy__ = _imslib.delete_SignalPath

# Register SignalPath in _imslib:
_imslib.SignalPath_swigregister(SignalPath)
class VelocityConfiguration(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    EncoderMode = property(_imslib.VelocityConfiguration_EncoderMode_get, _imslib.VelocityConfiguration_EncoderMode_set)
    VelocityMode = property(_imslib.VelocityConfiguration_VelocityMode_get, _imslib.VelocityConfiguration_VelocityMode_set)
    TrackingLoopProportionCoeff = property(_imslib.VelocityConfiguration_TrackingLoopProportionCoeff_get, _imslib.VelocityConfiguration_TrackingLoopProportionCoeff_set)
    TrackingLoopIntegrationCoeff = property(_imslib.VelocityConfiguration_TrackingLoopIntegrationCoeff_get, _imslib.VelocityConfiguration_TrackingLoopIntegrationCoeff_set)
    VelocityGain = property(_imslib.VelocityConfiguration_VelocityGain_get, _imslib.VelocityConfiguration_VelocityGain_set)

    def SetVelGain(self, ims, chan, EncoderFreq, DesiredFreqDeviation, Reverse=False):
        return _imslib.VelocityConfiguration_SetVelGain(self, ims, chan, EncoderFreq, DesiredFreqDeviation, Reverse)

    def __init__(self):
        _imslib.VelocityConfiguration_swiginit(self, _imslib.new_VelocityConfiguration())
    __swig_destroy__ = _imslib.delete_VelocityConfiguration

# Register VelocityConfiguration in _imslib:
_imslib.VelocityConfiguration_swigregister(VelocityConfiguration)

