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





from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_MMCorePy', [dirname(__file__)])
        except ImportError:
            import _MMCorePy
            return _MMCorePy
        if fp is not None:
            try:
                _mod = imp.load_module('_MMCorePy', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _MMCorePy = swig_import_helper()
    del swig_import_helper
else:
    import _MMCorePy
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _MMCorePy.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """
        value(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator const *

        """
        return _MMCorePy.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters:
            n: size_t

        incr(SwigPyIterator self) -> SwigPyIterator

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _MMCorePy.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

        Parameters:
            n: size_t

        decr(SwigPyIterator self) -> SwigPyIterator

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _MMCorePy.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _MMCorePy.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """
        equal(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _MMCorePy.SwigPyIterator_equal(self, *args)

    def copy(self):
        """
        copy(SwigPyIterator self) -> SwigPyIterator

        Parameters:
            self: swig::SwigPyIterator const *

        """
        return _MMCorePy.SwigPyIterator_copy(self)

    def next(self):
        """
        next(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _MMCorePy.SwigPyIterator_next(self)

    def __next__(self):
        """
        __next__(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _MMCorePy.SwigPyIterator___next__(self)

    def previous(self):
        """
        previous(SwigPyIterator self) -> PyObject *

        Parameters:
            self: swig::SwigPyIterator *

        """
        return _MMCorePy.SwigPyIterator_previous(self)

    def advance(self, *args):
        """
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _MMCorePy.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """
        __eq__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _MMCorePy.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(SwigPyIterator self, SwigPyIterator x) -> bool

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _MMCorePy.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _MMCorePy.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _MMCorePy.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """
        __add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        """
        return _MMCorePy.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

        Parameters:
            n: ptrdiff_t

        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

        Parameters:
            x: swig::SwigPyIterator const &

        """
        return _MMCorePy.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _MMCorePy.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class CharVector(_object):
    """Proxy of C++ std::vector<(char)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CharVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CharVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(CharVector self) -> SwigPyIterator

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """
        __nonzero__(CharVector self) -> bool

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(CharVector self) -> bool

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector___bool__(self)

    def __len__(self):
        """
        __len__(CharVector self) -> std::vector< char >::size_type

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector___len__(self)

    def pop(self):
        """
        pop(CharVector self) -> std::vector< char >::value_type

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(CharVector self, std::vector< char >::difference_type i, std::vector< char >::difference_type j) -> CharVector

        Parameters:
            i: std::vector< char >::difference_type
            j: std::vector< char >::difference_type

        """
        return _MMCorePy.CharVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(CharVector self, std::vector< char >::difference_type i, std::vector< char >::difference_type j, CharVector v=std::vector< char,std::allocator< char > >())

        Parameters:
            i: std::vector< char >::difference_type
            j: std::vector< char >::difference_type
            v: std::vector< char,std::allocator< char > > const &

        __setslice__(CharVector self, std::vector< char >::difference_type i, std::vector< char >::difference_type j)

        Parameters:
            i: std::vector< char >::difference_type
            j: std::vector< char >::difference_type

        """
        return _MMCorePy.CharVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(CharVector self, std::vector< char >::difference_type i, std::vector< char >::difference_type j)

        Parameters:
            i: std::vector< char >::difference_type
            j: std::vector< char >::difference_type

        """
        return _MMCorePy.CharVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(CharVector self, std::vector< char >::difference_type i)

        Parameters:
            i: std::vector< char >::difference_type

        __delitem__(CharVector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _MMCorePy.CharVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(CharVector self, PySliceObject * slice) -> CharVector

        Parameters:
            slice: PySliceObject *

        __getitem__(CharVector self, std::vector< char >::difference_type i) -> std::vector< char >::value_type const &

        Parameters:
            i: std::vector< char >::difference_type

        """
        return _MMCorePy.CharVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(CharVector self, PySliceObject * slice, CharVector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< char,std::allocator< char > > const &

        __setitem__(CharVector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(CharVector self, std::vector< char >::difference_type i, std::vector< char >::value_type const & x)

        Parameters:
            i: std::vector< char >::difference_type
            x: std::vector< char >::value_type const &

        """
        return _MMCorePy.CharVector___setitem__(self, *args)

    def append(self, *args):
        """
        append(CharVector self, std::vector< char >::value_type const & x)

        Parameters:
            x: std::vector< char >::value_type const &

        """
        return _MMCorePy.CharVector_append(self, *args)

    def empty(self):
        """
        empty(CharVector self) -> bool

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector_empty(self)

    def size(self):
        """
        size(CharVector self) -> std::vector< char >::size_type

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector_size(self)

    def clear(self):
        """
        clear(CharVector self)

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_clear(self)

    def swap(self, *args):
        """
        swap(CharVector self, CharVector v)

        Parameters:
            v: std::vector< char > &

        """
        return _MMCorePy.CharVector_swap(self, *args)

    def get_allocator(self):
        """
        get_allocator(CharVector self) -> std::vector< char >::allocator_type

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector_get_allocator(self)

    def begin(self):
        """
        begin(CharVector self) -> std::vector< char >::iterator

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_begin(self)

    def end(self):
        """
        end(CharVector self) -> std::vector< char >::iterator

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_end(self)

    def rbegin(self):
        """
        rbegin(CharVector self) -> std::vector< char >::reverse_iterator

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_rbegin(self)

    def rend(self):
        """
        rend(CharVector self) -> std::vector< char >::reverse_iterator

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_rend(self)

    def pop_back(self):
        """
        pop_back(CharVector self)

        Parameters:
            self: std::vector< char > *

        """
        return _MMCorePy.CharVector_pop_back(self)

    def erase(self, *args):
        """
        erase(CharVector self, std::vector< char >::iterator pos) -> std::vector< char >::iterator

        Parameters:
            pos: std::vector< char >::iterator

        erase(CharVector self, std::vector< char >::iterator first, std::vector< char >::iterator last) -> std::vector< char >::iterator

        Parameters:
            first: std::vector< char >::iterator
            last: std::vector< char >::iterator

        """
        return _MMCorePy.CharVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(char)> self) -> CharVector
        __init__(std::vector<(char)> self, CharVector arg2) -> CharVector

        Parameters:
            arg2: std::vector< char > const &

        __init__(std::vector<(char)> self, std::vector< char >::size_type size) -> CharVector

        Parameters:
            size: std::vector< char >::size_type

        __init__(std::vector<(char)> self, std::vector< char >::size_type size, std::vector< char >::value_type const & value) -> CharVector

        Parameters:
            size: std::vector< char >::size_type
            value: std::vector< char >::value_type const &

        """
        this = _MMCorePy.new_CharVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """
        push_back(CharVector self, std::vector< char >::value_type const & x)

        Parameters:
            x: std::vector< char >::value_type const &

        """
        return _MMCorePy.CharVector_push_back(self, *args)

    def front(self):
        """
        front(CharVector self) -> std::vector< char >::value_type const &

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector_front(self)

    def back(self):
        """
        back(CharVector self) -> std::vector< char >::value_type const &

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector_back(self)

    def assign(self, *args):
        """
        assign(CharVector self, std::vector< char >::size_type n, std::vector< char >::value_type const & x)

        Parameters:
            n: std::vector< char >::size_type
            x: std::vector< char >::value_type const &

        """
        return _MMCorePy.CharVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(CharVector self, std::vector< char >::size_type new_size)

        Parameters:
            new_size: std::vector< char >::size_type

        resize(CharVector self, std::vector< char >::size_type new_size, std::vector< char >::value_type const & x)

        Parameters:
            new_size: std::vector< char >::size_type
            x: std::vector< char >::value_type const &

        """
        return _MMCorePy.CharVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(CharVector self, std::vector< char >::iterator pos, std::vector< char >::value_type const & x) -> std::vector< char >::iterator

        Parameters:
            pos: std::vector< char >::iterator
            x: std::vector< char >::value_type const &

        insert(CharVector self, std::vector< char >::iterator pos, std::vector< char >::size_type n, std::vector< char >::value_type const & x)

        Parameters:
            pos: std::vector< char >::iterator
            n: std::vector< char >::size_type
            x: std::vector< char >::value_type const &

        """
        return _MMCorePy.CharVector_insert(self, *args)

    def reserve(self, *args):
        """
        reserve(CharVector self, std::vector< char >::size_type n)

        Parameters:
            n: std::vector< char >::size_type

        """
        return _MMCorePy.CharVector_reserve(self, *args)

    def capacity(self):
        """
        capacity(CharVector self) -> std::vector< char >::size_type

        Parameters:
            self: std::vector< char > const *

        """
        return _MMCorePy.CharVector_capacity(self)

    __swig_destroy__ = _MMCorePy.delete_CharVector
    __del__ = lambda self : None;
CharVector_swigregister = _MMCorePy.CharVector_swigregister
CharVector_swigregister(CharVector)

class LongVector(_object):
    """Proxy of C++ std::vector<(long)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LongVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LongVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(LongVector self) -> SwigPyIterator

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """
        __nonzero__(LongVector self) -> bool

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(LongVector self) -> bool

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector___bool__(self)

    def __len__(self):
        """
        __len__(LongVector self) -> std::vector< long >::size_type

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector___len__(self)

    def pop(self):
        """
        pop(LongVector self) -> std::vector< long >::value_type

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(LongVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j) -> LongVector

        Parameters:
            i: std::vector< long >::difference_type
            j: std::vector< long >::difference_type

        """
        return _MMCorePy.LongVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(LongVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j, LongVector v=std::vector< long,std::allocator< long > >())

        Parameters:
            i: std::vector< long >::difference_type
            j: std::vector< long >::difference_type
            v: std::vector< long,std::allocator< long > > const &

        __setslice__(LongVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)

        Parameters:
            i: std::vector< long >::difference_type
            j: std::vector< long >::difference_type

        """
        return _MMCorePy.LongVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(LongVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)

        Parameters:
            i: std::vector< long >::difference_type
            j: std::vector< long >::difference_type

        """
        return _MMCorePy.LongVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(LongVector self, std::vector< long >::difference_type i)

        Parameters:
            i: std::vector< long >::difference_type

        __delitem__(LongVector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _MMCorePy.LongVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(LongVector self, PySliceObject * slice) -> LongVector

        Parameters:
            slice: PySliceObject *

        __getitem__(LongVector self, std::vector< long >::difference_type i) -> std::vector< long >::value_type const &

        Parameters:
            i: std::vector< long >::difference_type

        """
        return _MMCorePy.LongVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(LongVector self, PySliceObject * slice, LongVector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< long,std::allocator< long > > const &

        __setitem__(LongVector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(LongVector self, std::vector< long >::difference_type i, std::vector< long >::value_type const & x)

        Parameters:
            i: std::vector< long >::difference_type
            x: std::vector< long >::value_type const &

        """
        return _MMCorePy.LongVector___setitem__(self, *args)

    def append(self, *args):
        """
        append(LongVector self, std::vector< long >::value_type const & x)

        Parameters:
            x: std::vector< long >::value_type const &

        """
        return _MMCorePy.LongVector_append(self, *args)

    def empty(self):
        """
        empty(LongVector self) -> bool

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector_empty(self)

    def size(self):
        """
        size(LongVector self) -> std::vector< long >::size_type

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector_size(self)

    def clear(self):
        """
        clear(LongVector self)

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_clear(self)

    def swap(self, *args):
        """
        swap(LongVector self, LongVector v)

        Parameters:
            v: std::vector< long > &

        """
        return _MMCorePy.LongVector_swap(self, *args)

    def get_allocator(self):
        """
        get_allocator(LongVector self) -> std::vector< long >::allocator_type

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector_get_allocator(self)

    def begin(self):
        """
        begin(LongVector self) -> std::vector< long >::iterator

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_begin(self)

    def end(self):
        """
        end(LongVector self) -> std::vector< long >::iterator

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_end(self)

    def rbegin(self):
        """
        rbegin(LongVector self) -> std::vector< long >::reverse_iterator

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_rbegin(self)

    def rend(self):
        """
        rend(LongVector self) -> std::vector< long >::reverse_iterator

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_rend(self)

    def pop_back(self):
        """
        pop_back(LongVector self)

        Parameters:
            self: std::vector< long > *

        """
        return _MMCorePy.LongVector_pop_back(self)

    def erase(self, *args):
        """
        erase(LongVector self, std::vector< long >::iterator pos) -> std::vector< long >::iterator

        Parameters:
            pos: std::vector< long >::iterator

        erase(LongVector self, std::vector< long >::iterator first, std::vector< long >::iterator last) -> std::vector< long >::iterator

        Parameters:
            first: std::vector< long >::iterator
            last: std::vector< long >::iterator

        """
        return _MMCorePy.LongVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(long)> self) -> LongVector
        __init__(std::vector<(long)> self, LongVector arg2) -> LongVector

        Parameters:
            arg2: std::vector< long > const &

        __init__(std::vector<(long)> self, std::vector< long >::size_type size) -> LongVector

        Parameters:
            size: std::vector< long >::size_type

        __init__(std::vector<(long)> self, std::vector< long >::size_type size, std::vector< long >::value_type const & value) -> LongVector

        Parameters:
            size: std::vector< long >::size_type
            value: std::vector< long >::value_type const &

        """
        this = _MMCorePy.new_LongVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """
        push_back(LongVector self, std::vector< long >::value_type const & x)

        Parameters:
            x: std::vector< long >::value_type const &

        """
        return _MMCorePy.LongVector_push_back(self, *args)

    def front(self):
        """
        front(LongVector self) -> std::vector< long >::value_type const &

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector_front(self)

    def back(self):
        """
        back(LongVector self) -> std::vector< long >::value_type const &

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector_back(self)

    def assign(self, *args):
        """
        assign(LongVector self, std::vector< long >::size_type n, std::vector< long >::value_type const & x)

        Parameters:
            n: std::vector< long >::size_type
            x: std::vector< long >::value_type const &

        """
        return _MMCorePy.LongVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(LongVector self, std::vector< long >::size_type new_size)

        Parameters:
            new_size: std::vector< long >::size_type

        resize(LongVector self, std::vector< long >::size_type new_size, std::vector< long >::value_type const & x)

        Parameters:
            new_size: std::vector< long >::size_type
            x: std::vector< long >::value_type const &

        """
        return _MMCorePy.LongVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(LongVector self, std::vector< long >::iterator pos, std::vector< long >::value_type const & x) -> std::vector< long >::iterator

        Parameters:
            pos: std::vector< long >::iterator
            x: std::vector< long >::value_type const &

        insert(LongVector self, std::vector< long >::iterator pos, std::vector< long >::size_type n, std::vector< long >::value_type const & x)

        Parameters:
            pos: std::vector< long >::iterator
            n: std::vector< long >::size_type
            x: std::vector< long >::value_type const &

        """
        return _MMCorePy.LongVector_insert(self, *args)

    def reserve(self, *args):
        """
        reserve(LongVector self, std::vector< long >::size_type n)

        Parameters:
            n: std::vector< long >::size_type

        """
        return _MMCorePy.LongVector_reserve(self, *args)

    def capacity(self):
        """
        capacity(LongVector self) -> std::vector< long >::size_type

        Parameters:
            self: std::vector< long > const *

        """
        return _MMCorePy.LongVector_capacity(self)

    __swig_destroy__ = _MMCorePy.delete_LongVector
    __del__ = lambda self : None;
LongVector_swigregister = _MMCorePy.LongVector_swigregister
LongVector_swigregister(LongVector)

class StrVector(_object):
    """Proxy of C++ std::vector<(std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StrVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(StrVector self) -> SwigPyIterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """
        __nonzero__(StrVector self) -> bool

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector___nonzero__(self)

    def __bool__(self):
        """
        __bool__(StrVector self) -> bool

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector___bool__(self)

    def __len__(self):
        """
        __len__(StrVector self) -> std::vector< std::string >::size_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector___len__(self)

    def pop(self):
        """
        pop(StrVector self) -> std::vector< std::string >::value_type

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StrVector

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type

        """
        return _MMCorePy.StrVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, 
            StrVector v=std::vector< std::string,std::allocator< std::string > >())

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type
            v: std::vector< std::string,std::allocator< std::string > > const &

        __setslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type

        """
        return _MMCorePy.StrVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters:
            i: std::vector< std::string >::difference_type
            j: std::vector< std::string >::difference_type

        """
        return _MMCorePy.StrVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(StrVector self, std::vector< std::string >::difference_type i)

        Parameters:
            i: std::vector< std::string >::difference_type

        __delitem__(StrVector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        """
        return _MMCorePy.StrVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(StrVector self, PySliceObject * slice) -> StrVector

        Parameters:
            slice: PySliceObject *

        __getitem__(StrVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

        Parameters:
            i: std::vector< std::string >::difference_type

        """
        return _MMCorePy.StrVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(StrVector self, PySliceObject * slice, StrVector v)

        Parameters:
            slice: PySliceObject *
            v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(StrVector self, PySliceObject * slice)

        Parameters:
            slice: PySliceObject *

        __setitem__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

        Parameters:
            i: std::vector< std::string >::difference_type
            x: std::vector< std::string >::value_type const &

        """
        return _MMCorePy.StrVector___setitem__(self, *args)

    def append(self, *args):
        """
        append(StrVector self, std::vector< std::string >::value_type const & x)

        Parameters:
            x: std::vector< std::string >::value_type const &

        """
        return _MMCorePy.StrVector_append(self, *args)

    def empty(self):
        """
        empty(StrVector self) -> bool

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector_empty(self)

    def size(self):
        """
        size(StrVector self) -> std::vector< std::string >::size_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector_size(self)

    def clear(self):
        """
        clear(StrVector self)

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_clear(self)

    def swap(self, *args):
        """
        swap(StrVector self, StrVector v)

        Parameters:
            v: std::vector< std::string > &

        """
        return _MMCorePy.StrVector_swap(self, *args)

    def get_allocator(self):
        """
        get_allocator(StrVector self) -> std::vector< std::string >::allocator_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector_get_allocator(self)

    def begin(self):
        """
        begin(StrVector self) -> std::vector< std::string >::iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_begin(self)

    def end(self):
        """
        end(StrVector self) -> std::vector< std::string >::iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_end(self)

    def rbegin(self):
        """
        rbegin(StrVector self) -> std::vector< std::string >::reverse_iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_rbegin(self)

    def rend(self):
        """
        rend(StrVector self) -> std::vector< std::string >::reverse_iterator

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_rend(self)

    def pop_back(self):
        """
        pop_back(StrVector self)

        Parameters:
            self: std::vector< std::string > *

        """
        return _MMCorePy.StrVector_pop_back(self)

    def erase(self, *args):
        """
        erase(StrVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator

        Parameters:
            pos: std::vector< std::string >::iterator

        erase(StrVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

        Parameters:
            first: std::vector< std::string >::iterator
            last: std::vector< std::string >::iterator

        """
        return _MMCorePy.StrVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(std::string)> self) -> StrVector
        __init__(std::vector<(std::string)> self, StrVector arg2) -> StrVector

        Parameters:
            arg2: std::vector< std::string > const &

        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> StrVector

        Parameters:
            size: std::vector< std::string >::size_type

        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StrVector

        Parameters:
            size: std::vector< std::string >::size_type
            value: std::vector< std::string >::value_type const &

        """
        this = _MMCorePy.new_StrVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """
        push_back(StrVector self, std::vector< std::string >::value_type const & x)

        Parameters:
            x: std::vector< std::string >::value_type const &

        """
        return _MMCorePy.StrVector_push_back(self, *args)

    def front(self):
        """
        front(StrVector self) -> std::vector< std::string >::value_type const &

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector_front(self)

    def back(self):
        """
        back(StrVector self) -> std::vector< std::string >::value_type const &

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector_back(self)

    def assign(self, *args):
        """
        assign(StrVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters:
            n: std::vector< std::string >::size_type
            x: std::vector< std::string >::value_type const &

        """
        return _MMCorePy.StrVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(StrVector self, std::vector< std::string >::size_type new_size)

        Parameters:
            new_size: std::vector< std::string >::size_type

        resize(StrVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

        Parameters:
            new_size: std::vector< std::string >::size_type
            x: std::vector< std::string >::value_type const &

        """
        return _MMCorePy.StrVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(StrVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator

        Parameters:
            pos: std::vector< std::string >::iterator
            x: std::vector< std::string >::value_type const &

        insert(StrVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, 
            std::vector< std::string >::value_type const & x)

        Parameters:
            pos: std::vector< std::string >::iterator
            n: std::vector< std::string >::size_type
            x: std::vector< std::string >::value_type const &

        """
        return _MMCorePy.StrVector_insert(self, *args)

    def reserve(self, *args):
        """
        reserve(StrVector self, std::vector< std::string >::size_type n)

        Parameters:
            n: std::vector< std::string >::size_type

        """
        return _MMCorePy.StrVector_reserve(self, *args)

    def capacity(self):
        """
        capacity(StrVector self) -> std::vector< std::string >::size_type

        Parameters:
            self: std::vector< std::string > const *

        """
        return _MMCorePy.StrVector_capacity(self)

    __swig_destroy__ = _MMCorePy.delete_StrVector
    __del__ = lambda self : None;
StrVector_swigregister = _MMCorePy.StrVector_swigregister
StrVector_swigregister(StrVector)

class pair_ss(_object):
    """Proxy of C++ std::pair<(std::string,std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pair_ss, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pair_ss, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::pair<(std::string,std::string)> self) -> pair_ss
        __init__(std::pair<(std::string,std::string)> self, std::string first, std::string second) -> pair_ss

        Parameters:
            first: std::string
            second: std::string

        __init__(std::pair<(std::string,std::string)> self, pair_ss p) -> pair_ss

        Parameters:
            p: std::pair< std::string,std::string > const &

        """
        this = _MMCorePy.new_pair_ss(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _MMCorePy.pair_ss_first_set
    __swig_getmethods__["first"] = _MMCorePy.pair_ss_first_get
    if _newclass:first = _swig_property(_MMCorePy.pair_ss_first_get, _MMCorePy.pair_ss_first_set)
    __swig_setmethods__["second"] = _MMCorePy.pair_ss_second_set
    __swig_getmethods__["second"] = _MMCorePy.pair_ss_second_get
    if _newclass:second = _swig_property(_MMCorePy.pair_ss_second_get, _MMCorePy.pair_ss_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _MMCorePy.delete_pair_ss
    __del__ = lambda self : None;
pair_ss_swigregister = _MMCorePy.pair_ss_swigregister
pair_ss_swigregister(pair_ss)

class StrMap(_object):
    """Proxy of C++ std::map<(std::string,std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StrMap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """
        iterator(StrMap self) -> SwigPyIterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """
        __nonzero__(StrMap self) -> bool

        Parameters:
            self: std::map< std::string,std::string > const *

        """
        return _MMCorePy.StrMap___nonzero__(self)

    def __bool__(self):
        """
        __bool__(StrMap self) -> bool

        Parameters:
            self: std::map< std::string,std::string > const *

        """
        return _MMCorePy.StrMap___bool__(self)

    def __len__(self):
        """
        __len__(StrMap self) -> std::map< std::string,std::string >::size_type

        Parameters:
            self: std::map< std::string,std::string > const *

        """
        return _MMCorePy.StrMap___len__(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args):
        """
        __getitem__(StrMap self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &

        Parameters:
            key: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(StrMap self, std::map< std::string,std::string >::key_type const & key)

        Parameters:
            key: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap___delitem__(self, *args)

    def has_key(self, *args):
        """
        has_key(StrMap self, std::map< std::string,std::string >::key_type const & key) -> bool

        Parameters:
            key: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap_has_key(self, *args)

    def keys(self):
        """
        keys(StrMap self) -> PyObject *

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_keys(self)

    def values(self):
        """
        values(StrMap self) -> PyObject *

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_values(self)

    def items(self):
        """
        items(StrMap self) -> PyObject *

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_items(self)

    def __contains__(self, *args):
        """
        __contains__(StrMap self, std::map< std::string,std::string >::key_type const & key) -> bool

        Parameters:
            key: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap___contains__(self, *args)

    def key_iterator(self):
        """
        key_iterator(StrMap self) -> SwigPyIterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_key_iterator(self)

    def value_iterator(self):
        """
        value_iterator(StrMap self) -> SwigPyIterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_value_iterator(self)

    def __setitem__(self, *args):
        """
        __setitem__(StrMap self, std::map< std::string,std::string >::key_type const & key)

        Parameters:
            key: std::map< std::string,std::string >::key_type const &

        __setitem__(StrMap self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)

        Parameters:
            key: std::map< std::string,std::string >::key_type const &
            x: std::map< std::string,std::string >::mapped_type const &

        """
        return _MMCorePy.StrMap___setitem__(self, *args)

    def asdict(self):
        """
        asdict(StrMap self) -> PyObject *

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_asdict(self)

    def __init__(self, *args): 
        """
        __init__(std::map<(std::string,std::string)> self, std::less< std::string > const & arg2) -> StrMap

        Parameters:
            arg2: std::less< std::string > const &

        __init__(std::map<(std::string,std::string)> self) -> StrMap
        __init__(std::map<(std::string,std::string)> self, StrMap arg2) -> StrMap

        Parameters:
            arg2: std::map< std::string,std::string > const &

        """
        this = _MMCorePy.new_StrMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """
        empty(StrMap self) -> bool

        Parameters:
            self: std::map< std::string,std::string > const *

        """
        return _MMCorePy.StrMap_empty(self)

    def size(self):
        """
        size(StrMap self) -> std::map< std::string,std::string >::size_type

        Parameters:
            self: std::map< std::string,std::string > const *

        """
        return _MMCorePy.StrMap_size(self)

    def clear(self):
        """
        clear(StrMap self)

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_clear(self)

    def swap(self, *args):
        """
        swap(StrMap self, StrMap v)

        Parameters:
            v: std::map< std::string,std::string > &

        """
        return _MMCorePy.StrMap_swap(self, *args)

    def get_allocator(self):
        """
        get_allocator(StrMap self) -> std::map< std::string,std::string >::allocator_type

        Parameters:
            self: std::map< std::string,std::string > const *

        """
        return _MMCorePy.StrMap_get_allocator(self)

    def begin(self):
        """
        begin(StrMap self) -> std::map< std::string,std::string >::iterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_begin(self)

    def end(self):
        """
        end(StrMap self) -> std::map< std::string,std::string >::iterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_end(self)

    def rbegin(self):
        """
        rbegin(StrMap self) -> std::map< std::string,std::string >::reverse_iterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_rbegin(self)

    def rend(self):
        """
        rend(StrMap self) -> std::map< std::string,std::string >::reverse_iterator

        Parameters:
            self: std::map< std::string,std::string > *

        """
        return _MMCorePy.StrMap_rend(self)

    def count(self, *args):
        """
        count(StrMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type

        Parameters:
            x: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap_count(self, *args)

    def erase(self, *args):
        """
        erase(StrMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type

        Parameters:
            x: std::map< std::string,std::string >::key_type const &

        erase(StrMap self, std::map< std::string,std::string >::iterator position)

        Parameters:
            position: std::map< std::string,std::string >::iterator

        erase(StrMap self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)

        Parameters:
            first: std::map< std::string,std::string >::iterator
            last: std::map< std::string,std::string >::iterator

        """
        return _MMCorePy.StrMap_erase(self, *args)

    def find(self, *args):
        """
        find(StrMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator

        Parameters:
            x: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap_find(self, *args)

    def lower_bound(self, *args):
        """
        lower_bound(StrMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator

        Parameters:
            x: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """
        upper_bound(StrMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator

        Parameters:
            x: std::map< std::string,std::string >::key_type const &

        """
        return _MMCorePy.StrMap_upper_bound(self, *args)

    __swig_destroy__ = _MMCorePy.delete_StrMap
    __del__ = lambda self : None;
StrMap_swigregister = _MMCorePy.StrMap_swigregister
StrMap_swigregister(StrMap)

MM_CODE_OK = _MMCorePy.MM_CODE_OK
MM_CODE_ERR = _MMCorePy.MM_CODE_ERR
DEVICE_OK = _MMCorePy.DEVICE_OK
DEVICE_ERR = _MMCorePy.DEVICE_ERR
DEVICE_INVALID_PROPERTY = _MMCorePy.DEVICE_INVALID_PROPERTY
DEVICE_INVALID_PROPERTY_VALUE = _MMCorePy.DEVICE_INVALID_PROPERTY_VALUE
DEVICE_DUPLICATE_PROPERTY = _MMCorePy.DEVICE_DUPLICATE_PROPERTY
DEVICE_INVALID_PROPERTY_TYPE = _MMCorePy.DEVICE_INVALID_PROPERTY_TYPE
DEVICE_NATIVE_MODULE_FAILED = _MMCorePy.DEVICE_NATIVE_MODULE_FAILED
DEVICE_UNSUPPORTED_DATA_FORMAT = _MMCorePy.DEVICE_UNSUPPORTED_DATA_FORMAT
DEVICE_INTERNAL_INCONSISTENCY = _MMCorePy.DEVICE_INTERNAL_INCONSISTENCY
DEVICE_NOT_SUPPORTED = _MMCorePy.DEVICE_NOT_SUPPORTED
DEVICE_UNKNOWN_LABEL = _MMCorePy.DEVICE_UNKNOWN_LABEL
DEVICE_UNSUPPORTED_COMMAND = _MMCorePy.DEVICE_UNSUPPORTED_COMMAND
DEVICE_UNKNOWN_POSITION = _MMCorePy.DEVICE_UNKNOWN_POSITION
DEVICE_NO_CALLBACK_REGISTERED = _MMCorePy.DEVICE_NO_CALLBACK_REGISTERED
DEVICE_SERIAL_COMMAND_FAILED = _MMCorePy.DEVICE_SERIAL_COMMAND_FAILED
DEVICE_SERIAL_BUFFER_OVERRUN = _MMCorePy.DEVICE_SERIAL_BUFFER_OVERRUN
DEVICE_SERIAL_INVALID_RESPONSE = _MMCorePy.DEVICE_SERIAL_INVALID_RESPONSE
DEVICE_SERIAL_TIMEOUT = _MMCorePy.DEVICE_SERIAL_TIMEOUT
DEVICE_SELF_REFERENCE = _MMCorePy.DEVICE_SELF_REFERENCE
DEVICE_NO_PROPERTY_DATA = _MMCorePy.DEVICE_NO_PROPERTY_DATA
DEVICE_DUPLICATE_LABEL = _MMCorePy.DEVICE_DUPLICATE_LABEL
DEVICE_INVALID_INPUT_PARAM = _MMCorePy.DEVICE_INVALID_INPUT_PARAM
DEVICE_BUFFER_OVERFLOW = _MMCorePy.DEVICE_BUFFER_OVERFLOW
DEVICE_NONEXISTENT_CHANNEL = _MMCorePy.DEVICE_NONEXISTENT_CHANNEL
DEVICE_INVALID_PROPERTY_LIMTS = _MMCorePy.DEVICE_INVALID_PROPERTY_LIMTS
DEVICE_SNAP_IMAGE_FAILED = _MMCorePy.DEVICE_SNAP_IMAGE_FAILED
DEVICE_IMAGE_PARAMS_FAILED = _MMCorePy.DEVICE_IMAGE_PARAMS_FAILED
DEVICE_CORE_FOCUS_STAGE_UNDEF = _MMCorePy.DEVICE_CORE_FOCUS_STAGE_UNDEF
DEVICE_CORE_EXPOSURE_FAILED = _MMCorePy.DEVICE_CORE_EXPOSURE_FAILED
DEVICE_CORE_CONFIG_FAILED = _MMCorePy.DEVICE_CORE_CONFIG_FAILED
DEVICE_CAMERA_BUSY_ACQUIRING = _MMCorePy.DEVICE_CAMERA_BUSY_ACQUIRING
DEVICE_INCOMPATIBLE_IMAGE = _MMCorePy.DEVICE_INCOMPATIBLE_IMAGE
DEVICE_CAN_NOT_SET_PROPERTY = _MMCorePy.DEVICE_CAN_NOT_SET_PROPERTY
DEVICE_CORE_CHANNEL_PRESETS_FAILED = _MMCorePy.DEVICE_CORE_CHANNEL_PRESETS_FAILED
DEVICE_LOCALLY_DEFINED_ERROR = _MMCorePy.DEVICE_LOCALLY_DEFINED_ERROR
DEVICE_NOT_CONNECTED = _MMCorePy.DEVICE_NOT_CONNECTED
DEVICE_COMM_HUB_MISSING = _MMCorePy.DEVICE_COMM_HUB_MISSING
DEVICE_DUPLICATE_LIBRARY = _MMCorePy.DEVICE_DUPLICATE_LIBRARY
DEVICE_PROPERTY_NOT_SEQUENCEABLE = _MMCorePy.DEVICE_PROPERTY_NOT_SEQUENCEABLE
DEVICE_SEQUENCE_TOO_LARGE = _MMCorePy.DEVICE_SEQUENCE_TOO_LARGE
DEVICE_OUT_OF_MEMORY = _MMCorePy.DEVICE_OUT_OF_MEMORY
DEVICE_NOT_YET_IMPLEMENTED = _MMCorePy.DEVICE_NOT_YET_IMPLEMENTED
UnknownType = _MMCorePy.UnknownType
AnyType = _MMCorePy.AnyType
CameraDevice = _MMCorePy.CameraDevice
ShutterDevice = _MMCorePy.ShutterDevice
StateDevice = _MMCorePy.StateDevice
StageDevice = _MMCorePy.StageDevice
XYStageDevice = _MMCorePy.XYStageDevice
SerialDevice = _MMCorePy.SerialDevice
GenericDevice = _MMCorePy.GenericDevice
AutoFocusDevice = _MMCorePy.AutoFocusDevice
CoreDevice = _MMCorePy.CoreDevice
ImageProcessorDevice = _MMCorePy.ImageProcessorDevice
SignalIODevice = _MMCorePy.SignalIODevice
MagnifierDevice = _MMCorePy.MagnifierDevice
SLMDevice = _MMCorePy.SLMDevice
HubDevice = _MMCorePy.HubDevice
GalvoDevice = _MMCorePy.GalvoDevice
Undef = _MMCorePy.Undef
String = _MMCorePy.String
Float = _MMCorePy.Float
Integer = _MMCorePy.Integer
NoAction = _MMCorePy.NoAction
BeforeGet = _MMCorePy.BeforeGet
AfterSet = _MMCorePy.AfterSet
IsSequenceable = _MMCorePy.IsSequenceable
AfterLoadSequence = _MMCorePy.AfterLoadSequence
StartSequence = _MMCorePy.StartSequence
StopSequence = _MMCorePy.StopSequence
InvalidPort = _MMCorePy.InvalidPort
SerialPort = _MMCorePy.SerialPort
USBPort = _MMCorePy.USBPort
HIDPort = _MMCorePy.HIDPort
FocusDirectionUnknown = _MMCorePy.FocusDirectionUnknown
FocusDirectionTowardSample = _MMCorePy.FocusDirectionTowardSample
FocusDirectionAwayFromSample = _MMCorePy.FocusDirectionAwayFromSample
Attention = _MMCorePy.Attention
Done = _MMCorePy.Done
StatusChanged = _MMCorePy.StatusChanged
Unimplemented = _MMCorePy.Unimplemented
Misconfigured = _MMCorePy.Misconfigured
CanNotCommunicate = _MMCorePy.CanNotCommunicate
CanCommunicate = _MMCorePy.CanCommunicate
class CMMError(Exception):
    """Proxy of C++ CMMError class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMMError, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(CMMError self, std::string const & msg, CMMError::Code code=MMERR_GENERIC) -> CMMError

        Parameters:
            msg: std::string const &
            code: CMMError::Code

        __init__(CMMError self, std::string const & msg) -> CMMError

        Parameters:
            msg: std::string const &

        __init__(CMMError self, char const * msg, CMMError::Code code=MMERR_GENERIC) -> CMMError

        Parameters:
            msg: char const *
            code: CMMError::Code

        __init__(CMMError self, char const * msg) -> CMMError

        Parameters:
            msg: char const *

        __init__(CMMError self, std::string const & msg, CMMError::Code code, CMMError underlyingError) -> CMMError

        Parameters:
            msg: std::string const &
            code: CMMError::Code
            underlyingError: CMMError const &

        __init__(CMMError self, char const * msg, CMMError::Code code, CMMError underlyingError) -> CMMError

        Parameters:
            msg: char const *
            code: CMMError::Code
            underlyingError: CMMError const &

        __init__(CMMError self, std::string const & msg, CMMError underlyingError) -> CMMError

        Parameters:
            msg: std::string const &
            underlyingError: CMMError const &

        __init__(CMMError self, char const * msg, CMMError underlyingError) -> CMMError

        Parameters:
            msg: char const *
            underlyingError: CMMError const &

        __init__(CMMError self, CMMError other) -> CMMError

        Parameters:
            other: CMMError const &

        """
        this = _MMCorePy.new_CMMError(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_CMMError
    __del__ = lambda self : None;
    def what(self):
        """
        what(CMMError self) -> char const *

        Parameters:
            self: CMMError const *

        """
        return _MMCorePy.CMMError_what(self)

    def getMsg(self):
        """
        getMsg(CMMError self) -> std::string

        Parameters:
            self: CMMError const *

        """
        return _MMCorePy.CMMError_getMsg(self)

    def getFullMsg(self):
        """
        getFullMsg(CMMError self) -> std::string

        Parameters:
            self: CMMError const *

        """
        return _MMCorePy.CMMError_getFullMsg(self)

    def getCode(self):
        """
        getCode(CMMError self) -> CMMError::Code

        Parameters:
            self: CMMError const *

        """
        return _MMCorePy.CMMError_getCode(self)

    def getSpecificCode(self):
        """
        getSpecificCode(CMMError self) -> CMMError::Code

        Parameters:
            self: CMMError const *

        """
        return _MMCorePy.CMMError_getSpecificCode(self)

    def getUnderlyingError(self):
        """
        getUnderlyingError(CMMError self) -> CMMError

        Parameters:
            self: CMMError const *

        """
        return _MMCorePy.CMMError_getUnderlyingError(self)

    def __getitem__(self, *args):
        """
        __getitem__(CMMError self, int n) -> std::string

        Parameters:
            n: int

        """
        return _MMCorePy.CMMError___getitem__(self, *args)

    def __str__(self):
        """
        __str__(CMMError self) -> std::string

        Parameters:
            self: CMMError *

        """
        return _MMCorePy.CMMError___str__(self)

CMMError_swigregister = _MMCorePy.CMMError_swigregister
CMMError_swigregister(CMMError)
cvar = _MMCorePy.cvar
MaxStrLength = cvar.MaxStrLength
g_Keyword_Name = cvar.g_Keyword_Name
g_Keyword_Description = cvar.g_Keyword_Description
g_Keyword_CameraName = cvar.g_Keyword_CameraName
g_Keyword_CameraID = cvar.g_Keyword_CameraID
g_Keyword_CameraChannelName = cvar.g_Keyword_CameraChannelName
g_Keyword_CameraChannelIndex = cvar.g_Keyword_CameraChannelIndex
g_Keyword_Binning = cvar.g_Keyword_Binning
g_Keyword_Exposure = cvar.g_Keyword_Exposure
g_Keyword_ActualExposure = cvar.g_Keyword_ActualExposure
g_Keyword_ActualInterval_ms = cvar.g_Keyword_ActualInterval_ms
g_Keyword_Interval_ms = cvar.g_Keyword_Interval_ms
g_Keyword_Elapsed_Time_ms = cvar.g_Keyword_Elapsed_Time_ms
g_Keyword_PixelType = cvar.g_Keyword_PixelType
g_Keyword_ReadoutTime = cvar.g_Keyword_ReadoutTime
g_Keyword_ReadoutMode = cvar.g_Keyword_ReadoutMode
g_Keyword_Gain = cvar.g_Keyword_Gain
g_Keyword_EMGain = cvar.g_Keyword_EMGain
g_Keyword_Offset = cvar.g_Keyword_Offset
g_Keyword_CCDTemperature = cvar.g_Keyword_CCDTemperature
g_Keyword_CCDTemperatureSetPoint = cvar.g_Keyword_CCDTemperatureSetPoint
g_Keyword_State = cvar.g_Keyword_State
g_Keyword_Label = cvar.g_Keyword_Label
g_Keyword_Position = cvar.g_Keyword_Position
g_Keyword_Type = cvar.g_Keyword_Type
g_Keyword_Delay = cvar.g_Keyword_Delay
g_Keyword_BaudRate = cvar.g_Keyword_BaudRate
g_Keyword_DataBits = cvar.g_Keyword_DataBits
g_Keyword_StopBits = cvar.g_Keyword_StopBits
g_Keyword_Parity = cvar.g_Keyword_Parity
g_Keyword_Handshaking = cvar.g_Keyword_Handshaking
g_Keyword_DelayBetweenCharsMs = cvar.g_Keyword_DelayBetweenCharsMs
g_Keyword_Port = cvar.g_Keyword_Port
g_Keyword_AnswerTimeout = cvar.g_Keyword_AnswerTimeout
g_Keyword_Speed = cvar.g_Keyword_Speed
g_Keyword_CoreDevice = cvar.g_Keyword_CoreDevice
g_Keyword_CoreInitialize = cvar.g_Keyword_CoreInitialize
g_Keyword_CoreCamera = cvar.g_Keyword_CoreCamera
g_Keyword_CoreShutter = cvar.g_Keyword_CoreShutter
g_Keyword_CoreXYStage = cvar.g_Keyword_CoreXYStage
g_Keyword_CoreFocus = cvar.g_Keyword_CoreFocus
g_Keyword_CoreAutoFocus = cvar.g_Keyword_CoreAutoFocus
g_Keyword_CoreAutoShutter = cvar.g_Keyword_CoreAutoShutter
g_Keyword_CoreChannelGroup = cvar.g_Keyword_CoreChannelGroup
g_Keyword_CoreImageProcessor = cvar.g_Keyword_CoreImageProcessor
g_Keyword_CoreSLM = cvar.g_Keyword_CoreSLM
g_Keyword_CoreGalvo = cvar.g_Keyword_CoreGalvo
g_Keyword_CoreTimeoutMs = cvar.g_Keyword_CoreTimeoutMs
g_Keyword_Channel = cvar.g_Keyword_Channel
g_Keyword_Version = cvar.g_Keyword_Version
g_Keyword_ColorMode = cvar.g_Keyword_ColorMode
g_Keyword_Transpose_SwapXY = cvar.g_Keyword_Transpose_SwapXY
g_Keyword_Transpose_MirrorX = cvar.g_Keyword_Transpose_MirrorX
g_Keyword_Transpose_MirrorY = cvar.g_Keyword_Transpose_MirrorY
g_Keyword_Transpose_Correction = cvar.g_Keyword_Transpose_Correction
g_Keyword_Closed_Position = cvar.g_Keyword_Closed_Position
g_Keyword_HubID = cvar.g_Keyword_HubID
g_Keyword_Meatdata_Exposure = cvar.g_Keyword_Meatdata_Exposure
g_Keyword_Metadata_Score = cvar.g_Keyword_Metadata_Score
g_Keyword_Metadata_ImageNumber = cvar.g_Keyword_Metadata_ImageNumber
g_Keyword_Metadata_StartTime = cvar.g_Keyword_Metadata_StartTime
g_Keyword_Metadata_ROI_X = cvar.g_Keyword_Metadata_ROI_X
g_Keyword_Metadata_ROI_Y = cvar.g_Keyword_Metadata_ROI_Y
g_FieldDelimiters = cvar.g_FieldDelimiters
g_CFGCommand_Device = cvar.g_CFGCommand_Device
g_CFGCommand_Label = cvar.g_CFGCommand_Label
g_CFGCommand_Property = cvar.g_CFGCommand_Property
g_CFGCommand_Configuration = cvar.g_CFGCommand_Configuration
g_CFGCommand_ConfigGroup = cvar.g_CFGCommand_ConfigGroup
g_CFGCommand_Equipment = cvar.g_CFGCommand_Equipment
g_CFGCommand_Delay = cvar.g_CFGCommand_Delay
g_CFGCommand_ImageSynchro = cvar.g_CFGCommand_ImageSynchro
g_CFGCommand_ConfigPixelSize = cvar.g_CFGCommand_ConfigPixelSize
g_CFGCommand_PixelSize_um = cvar.g_CFGCommand_PixelSize_um
g_CFGCommand_ParentID = cvar.g_CFGCommand_ParentID
g_CFGCommand_FocusDirection = cvar.g_CFGCommand_FocusDirection
g_CFGGroup_System = cvar.g_CFGGroup_System
g_CFGGroup_System_Startup = cvar.g_CFGGroup_System_Startup
g_CFGGroup_System_Shutdown = cvar.g_CFGGroup_System_Shutdown
g_CFGGroup_PixelSizeUm = cvar.g_CFGGroup_PixelSizeUm
_DATABITS_5 = cvar._DATABITS_5
_DATABITS_6 = cvar._DATABITS_6
_DATABITS_7 = cvar._DATABITS_7
_DATABITS_8 = cvar._DATABITS_8
_FLOWCONTROL_NONE = cvar._FLOWCONTROL_NONE
_FLOWCONTROL_RTSCTS_IN = cvar._FLOWCONTROL_RTSCTS_IN
_FLOWCONTROL_RTSCTS_OUT = cvar._FLOWCONTROL_RTSCTS_OUT
_FLOWCONTROL_XONXOFF_IN = cvar._FLOWCONTROL_XONXOFF_IN
_FLOWCONTROL_XONXOFF_OUT = cvar._FLOWCONTROL_XONXOFF_OUT
_PARITY_EVEN = cvar._PARITY_EVEN
_PARITY_MARK = cvar._PARITY_MARK
_PARITY_NONE = cvar._PARITY_NONE
_PARITY_ODD = cvar._PARITY_ODD
_PARITY_SPACE = cvar._PARITY_SPACE
_STOPBITS_1 = cvar._STOPBITS_1
_STOPBITS_1_5 = cvar._STOPBITS_1_5
_STOPBITS_2 = cvar._STOPBITS_2

class PropertySetting(_object):
    """Proxy of C++ PropertySetting class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PropertySetting, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PropertySetting, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(PropertySetting self, char const * deviceLabel, char const * prop, char const * value, bool readOnly=False) -> PropertySetting

        Parameters:
            deviceLabel: char const *
            prop: char const *
            value: char const *
            readOnly: bool

        __init__(PropertySetting self, char const * deviceLabel, char const * prop, char const * value) -> PropertySetting

        Parameters:
            deviceLabel: char const *
            prop: char const *
            value: char const *

        __init__(PropertySetting self) -> PropertySetting
        """
        this = _MMCorePy.new_PropertySetting(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_PropertySetting
    __del__ = lambda self : None;
    def getDeviceLabel(self):
        """
        getDeviceLabel(PropertySetting self) -> std::string

        Parameters:
            self: PropertySetting const *

        """
        return _MMCorePy.PropertySetting_getDeviceLabel(self)

    def getPropertyName(self):
        """
        getPropertyName(PropertySetting self) -> std::string

        Parameters:
            self: PropertySetting const *

        """
        return _MMCorePy.PropertySetting_getPropertyName(self)

    def getReadOnly(self):
        """
        getReadOnly(PropertySetting self) -> bool

        Parameters:
            self: PropertySetting const *

        """
        return _MMCorePy.PropertySetting_getReadOnly(self)

    def getPropertyValue(self):
        """
        getPropertyValue(PropertySetting self) -> std::string

        Parameters:
            self: PropertySetting const *

        """
        return _MMCorePy.PropertySetting_getPropertyValue(self)

    def getKey(self):
        """
        getKey(PropertySetting self) -> std::string

        Parameters:
            self: PropertySetting const *

        """
        return _MMCorePy.PropertySetting_getKey(self)

    def generateKey(*args):
        """
        generateKey(char const * device, char const * prop) -> std::string

        Parameters:
            device: char const *
            prop: char const *

        """
        return _MMCorePy.PropertySetting_generateKey(*args)

    if _newclass:generateKey = staticmethod(generateKey)
    __swig_getmethods__["generateKey"] = lambda x: generateKey
    def getVerbose(self):
        """
        getVerbose(PropertySetting self) -> std::string

        Parameters:
            self: PropertySetting const *

        """
        return _MMCorePy.PropertySetting_getVerbose(self)

    def isEqualTo(self, *args):
        """
        isEqualTo(PropertySetting self, PropertySetting ps) -> bool

        Parameters:
            ps: PropertySetting const &

        """
        return _MMCorePy.PropertySetting_isEqualTo(self, *args)

PropertySetting_swigregister = _MMCorePy.PropertySetting_swigregister
PropertySetting_swigregister(PropertySetting)

def PropertySetting_generateKey(*args):
  """
    PropertySetting_generateKey(char const * device, char const * prop) -> std::string

    Parameters:
        device: char const *
        prop: char const *

    """
  return _MMCorePy.PropertySetting_generateKey(*args)

class PropertyPair(_object):
    """Proxy of C++ PropertyPair class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PropertyPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PropertyPair, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(PropertyPair self, char const * prop, char const * value) -> PropertyPair

        Parameters:
            prop: char const *
            value: char const *

        __init__(PropertyPair self) -> PropertyPair
        """
        this = _MMCorePy.new_PropertyPair(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_PropertyPair
    __del__ = lambda self : None;
    def getPropertyName(self):
        """
        getPropertyName(PropertyPair self) -> std::string

        Parameters:
            self: PropertyPair const *

        """
        return _MMCorePy.PropertyPair_getPropertyName(self)

    def getPropertyValue(self):
        """
        getPropertyValue(PropertyPair self) -> std::string

        Parameters:
            self: PropertyPair const *

        """
        return _MMCorePy.PropertyPair_getPropertyValue(self)

PropertyPair_swigregister = _MMCorePy.PropertyPair_swigregister
PropertyPair_swigregister(PropertyPair)

class Configuration(_object):
    """Proxy of C++ Configuration class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Configuration, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Configuration, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(Configuration self) -> Configuration"""
        this = _MMCorePy.new_Configuration()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_Configuration
    __del__ = lambda self : None;
    def addSetting(self, *args):
        """
        addSetting(Configuration self, PropertySetting setting)

        Parameters:
            setting: PropertySetting const &

        """
        return _MMCorePy.Configuration_addSetting(self, *args)

    def deleteSetting(self, *args):
        """
        deleteSetting(Configuration self, char const * device, char const * prop)

        Parameters:
            device: char const *
            prop: char const *

        """
        return _MMCorePy.Configuration_deleteSetting(self, *args)

    def isPropertyIncluded(self, *args):
        """
        isPropertyIncluded(Configuration self, char const * device, char const * property) -> bool

        Parameters:
            device: char const *
            property: char const *

        """
        return _MMCorePy.Configuration_isPropertyIncluded(self, *args)

    def isSettingIncluded(self, *args):
        """
        isSettingIncluded(Configuration self, PropertySetting ps) -> bool

        Parameters:
            ps: PropertySetting const &

        """
        return _MMCorePy.Configuration_isSettingIncluded(self, *args)

    def isConfigurationIncluded(self, *args):
        """
        isConfigurationIncluded(Configuration self, Configuration cfg) -> bool

        Parameters:
            cfg: Configuration const &

        """
        return _MMCorePy.Configuration_isConfigurationIncluded(self, *args)

    def getSetting(self, *args):
        """
        getSetting(Configuration self, size_t index) -> PropertySetting

        Parameters:
            index: size_t

        getSetting(Configuration self, char const * device, char const * prop) -> PropertySetting

        Parameters:
            device: char const *
            prop: char const *

        """
        return _MMCorePy.Configuration_getSetting(self, *args)

    def size(self):
        """
        size(Configuration self) -> size_t

        Parameters:
            self: Configuration const *

        """
        return _MMCorePy.Configuration_size(self)

    def getVerbose(self):
        """
        getVerbose(Configuration self) -> std::string

        Parameters:
            self: Configuration const *

        """
        return _MMCorePy.Configuration_getVerbose(self)

Configuration_swigregister = _MMCorePy.Configuration_swigregister
Configuration_swigregister(Configuration)

class PropertyBlock(_object):
    """Proxy of C++ PropertyBlock class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PropertyBlock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PropertyBlock, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(PropertyBlock self) -> PropertyBlock"""
        this = _MMCorePy.new_PropertyBlock()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_PropertyBlock
    __del__ = lambda self : None;
    def addPair(self, *args):
        """
        addPair(PropertyBlock self, PropertyPair pair)

        Parameters:
            pair: PropertyPair const &

        """
        return _MMCorePy.PropertyBlock_addPair(self, *args)

    def getPair(self, *args):
        """
        getPair(PropertyBlock self, size_t index) -> PropertyPair

        Parameters:
            index: size_t

        """
        return _MMCorePy.PropertyBlock_getPair(self, *args)

    def size(self):
        """
        size(PropertyBlock self) -> size_t

        Parameters:
            self: PropertyBlock const *

        """
        return _MMCorePy.PropertyBlock_size(self)

    def getValue(self, *args):
        """
        getValue(PropertyBlock self, char const * key) -> std::string

        Parameters:
            key: char const *

        """
        return _MMCorePy.PropertyBlock_getValue(self, *args)

PropertyBlock_swigregister = _MMCorePy.PropertyBlock_swigregister
PropertyBlock_swigregister(PropertyBlock)

class CMMCore(_object):
    """Proxy of C++ CMMCore class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMCore, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMMCore, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(CMMCore self) -> CMMCore"""
        this = _MMCorePy.new_CMMCore()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_CMMCore
    __del__ = lambda self : None;
    def noop():
        """noop()"""
        return _MMCorePy.CMMCore_noop()

    if _newclass:noop = staticmethod(noop)
    __swig_getmethods__["noop"] = lambda x: noop
    def loadDevice(self, *args):
        """
        loadDevice(CMMCore self, char const * label, char const * moduleName, char const * deviceName)

        Parameters:
            label: char const *
            moduleName: char const *
            deviceName: char const *

        """
        return _MMCorePy.CMMCore_loadDevice(self, *args)

    def unloadDevice(self, *args):
        """
        unloadDevice(CMMCore self, char const * label)

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_unloadDevice(self, *args)

    def unloadAllDevices(self):
        """
        unloadAllDevices(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_unloadAllDevices(self)

    def initializeAllDevices(self):
        """
        initializeAllDevices(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_initializeAllDevices(self)

    def initializeDevice(self, *args):
        """
        initializeDevice(CMMCore self, char const * label)

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_initializeDevice(self, *args)

    def reset(self):
        """
        reset(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_reset(self)

    def unloadLibrary(self, *args):
        """
        unloadLibrary(CMMCore self, char const * moduleName)

        Parameters:
            moduleName: char const *

        """
        return _MMCorePy.CMMCore_unloadLibrary(self, *args)

    def updateCoreProperties(self):
        """
        updateCoreProperties(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_updateCoreProperties(self)

    def getCoreErrorText(self, *args):
        """
        getCoreErrorText(CMMCore self, int code) -> std::string

        Parameters:
            code: int

        """
        return _MMCorePy.CMMCore_getCoreErrorText(self, *args)

    def getVersionInfo(self):
        """
        getVersionInfo(CMMCore self) -> std::string

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getVersionInfo(self)

    def getAPIVersionInfo(self):
        """
        getAPIVersionInfo(CMMCore self) -> std::string

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getAPIVersionInfo(self)

    def getSystemState(self):
        """
        getSystemState(CMMCore self) -> Configuration

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getSystemState(self)

    def setSystemState(self, *args):
        """
        setSystemState(CMMCore self, Configuration conf)

        Parameters:
            conf: Configuration const &

        """
        return _MMCorePy.CMMCore_setSystemState(self, *args)

    def getConfigState(self, *args):
        """
        getConfigState(CMMCore self, char const * group, char const * config) -> Configuration

        Parameters:
            group: char const *
            config: char const *

        """
        return _MMCorePy.CMMCore_getConfigState(self, *args)

    def getConfigGroupState(self, *args):
        """
        getConfigGroupState(CMMCore self, char const * group) -> Configuration

        Parameters:
            group: char const *

        """
        return _MMCorePy.CMMCore_getConfigGroupState(self, *args)

    def saveSystemState(self, *args):
        """
        saveSystemState(CMMCore self, char const * fileName)

        Parameters:
            fileName: char const *

        """
        return _MMCorePy.CMMCore_saveSystemState(self, *args)

    def loadSystemState(self, *args):
        """
        loadSystemState(CMMCore self, char const * fileName)

        Parameters:
            fileName: char const *

        """
        return _MMCorePy.CMMCore_loadSystemState(self, *args)

    def saveSystemConfiguration(self, *args):
        """
        saveSystemConfiguration(CMMCore self, char const * fileName)

        Parameters:
            fileName: char const *

        """
        return _MMCorePy.CMMCore_saveSystemConfiguration(self, *args)

    def loadSystemConfiguration(self, *args):
        """
        loadSystemConfiguration(CMMCore self, char const * fileName)

        Parameters:
            fileName: char const *

        """
        return _MMCorePy.CMMCore_loadSystemConfiguration(self, *args)

    def registerCallback(self, *args):
        """
        registerCallback(CMMCore self, MMEventCallback cb)

        Parameters:
            cb: MMEventCallback *

        """
        return _MMCorePy.CMMCore_registerCallback(self, *args)

    def setPrimaryLogFile(self, *args):
        """
        setPrimaryLogFile(CMMCore self, char const * filename, bool truncate=False)

        Parameters:
            filename: char const *
            truncate: bool

        setPrimaryLogFile(CMMCore self, char const * filename)

        Parameters:
            filename: char const *

        """
        return _MMCorePy.CMMCore_setPrimaryLogFile(self, *args)

    def getPrimaryLogFile(self):
        """
        getPrimaryLogFile(CMMCore self) -> std::string

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getPrimaryLogFile(self)

    def logMessage(self, *args):
        """
        logMessage(CMMCore self, char const * msg)

        Parameters:
            msg: char const *

        logMessage(CMMCore self, char const * msg, bool debugOnly)

        Parameters:
            msg: char const *
            debugOnly: bool

        """
        return _MMCorePy.CMMCore_logMessage(self, *args)

    def enableDebugLog(self, *args):
        """
        enableDebugLog(CMMCore self, bool enable)

        Parameters:
            enable: bool

        """
        return _MMCorePy.CMMCore_enableDebugLog(self, *args)

    def debugLogEnabled(self):
        """
        debugLogEnabled(CMMCore self) -> bool

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_debugLogEnabled(self)

    def enableStderrLog(self, *args):
        """
        enableStderrLog(CMMCore self, bool enable)

        Parameters:
            enable: bool

        """
        return _MMCorePy.CMMCore_enableStderrLog(self, *args)

    def stderrLogEnabled(self):
        """
        stderrLogEnabled(CMMCore self) -> bool

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_stderrLogEnabled(self)

    def startSecondaryLogFile(self, *args):
        """
        startSecondaryLogFile(CMMCore self, char const * filename, bool enableDebug, bool truncate=True, bool synchronous=False) -> int

        Parameters:
            filename: char const *
            enableDebug: bool
            truncate: bool
            synchronous: bool

        startSecondaryLogFile(CMMCore self, char const * filename, bool enableDebug, bool truncate=True) -> int

        Parameters:
            filename: char const *
            enableDebug: bool
            truncate: bool

        startSecondaryLogFile(CMMCore self, char const * filename, bool enableDebug) -> int

        Parameters:
            filename: char const *
            enableDebug: bool

        """
        return _MMCorePy.CMMCore_startSecondaryLogFile(self, *args)

    def stopSecondaryLogFile(self, *args):
        """
        stopSecondaryLogFile(CMMCore self, int handle)

        Parameters:
            handle: int

        """
        return _MMCorePy.CMMCore_stopSecondaryLogFile(self, *args)

    def getDeviceAdapterSearchPaths(self):
        """
        getDeviceAdapterSearchPaths(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getDeviceAdapterSearchPaths(self)

    def setDeviceAdapterSearchPaths(self, *args):
        """
        setDeviceAdapterSearchPaths(CMMCore self, StrVector paths)

        Parameters:
            paths: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _MMCorePy.CMMCore_setDeviceAdapterSearchPaths(self, *args)

    def addSearchPath(*args):
        """
        addSearchPath(char const * path)

        Parameters:
            path: char const *

        """
        return _MMCorePy.CMMCore_addSearchPath(*args)

    if _newclass:addSearchPath = staticmethod(addSearchPath)
    __swig_getmethods__["addSearchPath"] = lambda x: addSearchPath
    def getDeviceAdapterNames(self):
        """
        getDeviceAdapterNames(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getDeviceAdapterNames(self)

    def getDeviceLibraries():
        """getDeviceLibraries() -> StrVector"""
        return _MMCorePy.CMMCore_getDeviceLibraries()

    if _newclass:getDeviceLibraries = staticmethod(getDeviceLibraries)
    __swig_getmethods__["getDeviceLibraries"] = lambda x: getDeviceLibraries
    def getAvailableDevices(self, *args):
        """
        getAvailableDevices(CMMCore self, char const * library) -> StrVector

        Parameters:
            library: char const *

        """
        return _MMCorePy.CMMCore_getAvailableDevices(self, *args)

    def getAvailableDeviceDescriptions(self, *args):
        """
        getAvailableDeviceDescriptions(CMMCore self, char const * library) -> StrVector

        Parameters:
            library: char const *

        """
        return _MMCorePy.CMMCore_getAvailableDeviceDescriptions(self, *args)

    def getAvailableDeviceTypes(self, *args):
        """
        getAvailableDeviceTypes(CMMCore self, char const * library) -> LongVector

        Parameters:
            library: char const *

        """
        return _MMCorePy.CMMCore_getAvailableDeviceTypes(self, *args)

    def getLoadedDevices(self):
        """
        getLoadedDevices(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getLoadedDevices(self)

    def getLoadedDevicesOfType(self, *args):
        """
        getLoadedDevicesOfType(CMMCore self, MM::DeviceType devType) -> StrVector

        Parameters:
            devType: enum MM::DeviceType

        """
        return _MMCorePy.CMMCore_getLoadedDevicesOfType(self, *args)

    def getDeviceType(self, *args):
        """
        getDeviceType(CMMCore self, char const * label) -> MM::DeviceType

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getDeviceType(self, *args)

    def getDeviceLibrary(self, *args):
        """
        getDeviceLibrary(CMMCore self, char const * label) -> std::string

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getDeviceLibrary(self, *args)

    def getDeviceName(self, *args):
        """
        getDeviceName(CMMCore self, char const * label) -> std::string

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getDeviceName(self, *args)

    def getDeviceDescription(self, *args):
        """
        getDeviceDescription(CMMCore self, char const * label) -> std::string

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getDeviceDescription(self, *args)

    def getDevicePropertyNames(self, *args):
        """
        getDevicePropertyNames(CMMCore self, char const * label) -> StrVector

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getDevicePropertyNames(self, *args)

    def hasProperty(self, *args):
        """
        hasProperty(CMMCore self, char const * label, char const * propName) -> bool

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_hasProperty(self, *args)

    def getProperty(self, *args):
        """
        getProperty(CMMCore self, char const * label, char const * propName) -> std::string

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getProperty(self, *args)

    def setProperty(self, *args):
        """
        setProperty(CMMCore self, char const * label, char const * propName, char const * propValue)

        Parameters:
            label: char const *
            propName: char const *
            propValue: char const *

        setProperty(CMMCore self, char const * label, char const * propName, bool const propValue)

        Parameters:
            label: char const *
            propName: char const *
            propValue: bool const

        setProperty(CMMCore self, char const * label, char const * propName, long const propValue)

        Parameters:
            label: char const *
            propName: char const *
            propValue: long const

        setProperty(CMMCore self, char const * label, char const * propName, float const propValue)

        Parameters:
            label: char const *
            propName: char const *
            propValue: float const

        setProperty(CMMCore self, char const * label, char const * propName, double const propValue)

        Parameters:
            label: char const *
            propName: char const *
            propValue: double const

        """
        return _MMCorePy.CMMCore_setProperty(self, *args)

    def getAllowedPropertyValues(self, *args):
        """
        getAllowedPropertyValues(CMMCore self, char const * label, char const * propName) -> StrVector

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getAllowedPropertyValues(self, *args)

    def isPropertyReadOnly(self, *args):
        """
        isPropertyReadOnly(CMMCore self, char const * label, char const * propName) -> bool

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_isPropertyReadOnly(self, *args)

    def isPropertyPreInit(self, *args):
        """
        isPropertyPreInit(CMMCore self, char const * label, char const * propName) -> bool

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_isPropertyPreInit(self, *args)

    def isPropertySequenceable(self, *args):
        """
        isPropertySequenceable(CMMCore self, char const * label, char const * propName) -> bool

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_isPropertySequenceable(self, *args)

    def hasPropertyLimits(self, *args):
        """
        hasPropertyLimits(CMMCore self, char const * label, char const * propName) -> bool

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_hasPropertyLimits(self, *args)

    def getPropertyLowerLimit(self, *args):
        """
        getPropertyLowerLimit(CMMCore self, char const * label, char const * propName) -> double

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getPropertyLowerLimit(self, *args)

    def getPropertyUpperLimit(self, *args):
        """
        getPropertyUpperLimit(CMMCore self, char const * label, char const * propName) -> double

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getPropertyUpperLimit(self, *args)

    def getPropertyType(self, *args):
        """
        getPropertyType(CMMCore self, char const * label, char const * propName) -> MM::PropertyType

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getPropertyType(self, *args)

    def startPropertySequence(self, *args):
        """
        startPropertySequence(CMMCore self, char const * label, char const * propName)

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_startPropertySequence(self, *args)

    def stopPropertySequence(self, *args):
        """
        stopPropertySequence(CMMCore self, char const * label, char const * propName)

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_stopPropertySequence(self, *args)

    def getPropertySequenceMaxLength(self, *args):
        """
        getPropertySequenceMaxLength(CMMCore self, char const * label, char const * propName) -> long

        Parameters:
            label: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getPropertySequenceMaxLength(self, *args)

    def loadPropertySequence(self, *args):
        """
        loadPropertySequence(CMMCore self, char const * label, char const * propName, StrVector eventSequence)

        Parameters:
            label: char const *
            propName: char const *
            eventSequence: std::vector< std::string,std::allocator< std::string > >

        """
        return _MMCorePy.CMMCore_loadPropertySequence(self, *args)

    def deviceBusy(self, *args):
        """
        deviceBusy(CMMCore self, char const * label) -> bool

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_deviceBusy(self, *args)

    def waitForDevice(self, *args):
        """
        waitForDevice(CMMCore self, char const * label)

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_waitForDevice(self, *args)

    def waitForConfig(self, *args):
        """
        waitForConfig(CMMCore self, char const * group, char const * configName)

        Parameters:
            group: char const *
            configName: char const *

        """
        return _MMCorePy.CMMCore_waitForConfig(self, *args)

    def systemBusy(self):
        """
        systemBusy(CMMCore self) -> bool

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_systemBusy(self)

    def waitForSystem(self):
        """
        waitForSystem(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_waitForSystem(self)

    def waitForImageSynchro(self):
        """
        waitForImageSynchro(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_waitForImageSynchro(self)

    def deviceTypeBusy(self, *args):
        """
        deviceTypeBusy(CMMCore self, MM::DeviceType devType) -> bool

        Parameters:
            devType: enum MM::DeviceType

        """
        return _MMCorePy.CMMCore_deviceTypeBusy(self, *args)

    def waitForDeviceType(self, *args):
        """
        waitForDeviceType(CMMCore self, MM::DeviceType devType)

        Parameters:
            devType: enum MM::DeviceType

        """
        return _MMCorePy.CMMCore_waitForDeviceType(self, *args)

    def getDeviceDelayMs(self, *args):
        """
        getDeviceDelayMs(CMMCore self, char const * label) -> double

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getDeviceDelayMs(self, *args)

    def setDeviceDelayMs(self, *args):
        """
        setDeviceDelayMs(CMMCore self, char const * label, double delayMs)

        Parameters:
            label: char const *
            delayMs: double

        """
        return _MMCorePy.CMMCore_setDeviceDelayMs(self, *args)

    def usesDeviceDelay(self, *args):
        """
        usesDeviceDelay(CMMCore self, char const * label) -> bool

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_usesDeviceDelay(self, *args)

    def setTimeoutMs(self, *args):
        """
        setTimeoutMs(CMMCore self, long timeoutMs)

        Parameters:
            timeoutMs: long

        """
        return _MMCorePy.CMMCore_setTimeoutMs(self, *args)

    def getTimeoutMs(self):
        """
        getTimeoutMs(CMMCore self) -> long

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getTimeoutMs(self)

    def sleep(self, *args):
        """
        sleep(CMMCore self, double intervalMs)

        Parameters:
            intervalMs: double

        """
        return _MMCorePy.CMMCore_sleep(self, *args)

    def getCameraDevice(self):
        """
        getCameraDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getCameraDevice(self)

    def getShutterDevice(self):
        """
        getShutterDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getShutterDevice(self)

    def getFocusDevice(self):
        """
        getFocusDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getFocusDevice(self)

    def getXYStageDevice(self):
        """
        getXYStageDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getXYStageDevice(self)

    def getAutoFocusDevice(self):
        """
        getAutoFocusDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getAutoFocusDevice(self)

    def getImageProcessorDevice(self):
        """
        getImageProcessorDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getImageProcessorDevice(self)

    def getSLMDevice(self):
        """
        getSLMDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getSLMDevice(self)

    def getGalvoDevice(self):
        """
        getGalvoDevice(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getGalvoDevice(self)

    def getChannelGroup(self):
        """
        getChannelGroup(CMMCore self) -> std::string

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getChannelGroup(self)

    def setCameraDevice(self, *args):
        """
        setCameraDevice(CMMCore self, char const * cameraLabel)

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_setCameraDevice(self, *args)

    def setShutterDevice(self, *args):
        """
        setShutterDevice(CMMCore self, char const * shutterLabel)

        Parameters:
            shutterLabel: char const *

        """
        return _MMCorePy.CMMCore_setShutterDevice(self, *args)

    def setFocusDevice(self, *args):
        """
        setFocusDevice(CMMCore self, char const * focusLabel)

        Parameters:
            focusLabel: char const *

        """
        return _MMCorePy.CMMCore_setFocusDevice(self, *args)

    def setXYStageDevice(self, *args):
        """
        setXYStageDevice(CMMCore self, char const * xyStageLabel)

        Parameters:
            xyStageLabel: char const *

        """
        return _MMCorePy.CMMCore_setXYStageDevice(self, *args)

    def setAutoFocusDevice(self, *args):
        """
        setAutoFocusDevice(CMMCore self, char const * focusLabel)

        Parameters:
            focusLabel: char const *

        """
        return _MMCorePy.CMMCore_setAutoFocusDevice(self, *args)

    def setImageProcessorDevice(self, *args):
        """
        setImageProcessorDevice(CMMCore self, char const * procLabel)

        Parameters:
            procLabel: char const *

        """
        return _MMCorePy.CMMCore_setImageProcessorDevice(self, *args)

    def setSLMDevice(self, *args):
        """
        setSLMDevice(CMMCore self, char const * slmLabel)

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_setSLMDevice(self, *args)

    def setGalvoDevice(self, *args):
        """
        setGalvoDevice(CMMCore self, char const * galvoLabel)

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_setGalvoDevice(self, *args)

    def setChannelGroup(self, *args):
        """
        setChannelGroup(CMMCore self, char const * channelGroup)

        Parameters:
            channelGroup: char const *

        """
        return _MMCorePy.CMMCore_setChannelGroup(self, *args)

    def getSystemStateCache(self):
        """
        getSystemStateCache(CMMCore self) -> Configuration

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getSystemStateCache(self)

    def updateSystemStateCache(self):
        """
        updateSystemStateCache(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_updateSystemStateCache(self)

    def getPropertyFromCache(self, *args):
        """
        getPropertyFromCache(CMMCore self, char const * deviceLabel, char const * propName) -> std::string

        Parameters:
            deviceLabel: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_getPropertyFromCache(self, *args)

    def getCurrentConfigFromCache(self, *args):
        """
        getCurrentConfigFromCache(CMMCore self, char const * groupName) -> std::string

        Parameters:
            groupName: char const *

        """
        return _MMCorePy.CMMCore_getCurrentConfigFromCache(self, *args)

    def getConfigGroupStateFromCache(self, *args):
        """
        getConfigGroupStateFromCache(CMMCore self, char const * group) -> Configuration

        Parameters:
            group: char const *

        """
        return _MMCorePy.CMMCore_getConfigGroupStateFromCache(self, *args)

    def defineConfig(self, *args):
        """
        defineConfig(CMMCore self, char const * groupName, char const * configName)

        Parameters:
            groupName: char const *
            configName: char const *

        defineConfig(CMMCore self, char const * groupName, char const * configName, char const * deviceLabel, char const * propName, 
            char const * value)

        Parameters:
            groupName: char const *
            configName: char const *
            deviceLabel: char const *
            propName: char const *
            value: char const *

        """
        return _MMCorePy.CMMCore_defineConfig(self, *args)

    def defineConfigGroup(self, *args):
        """
        defineConfigGroup(CMMCore self, char const * groupName)

        Parameters:
            groupName: char const *

        """
        return _MMCorePy.CMMCore_defineConfigGroup(self, *args)

    def deleteConfigGroup(self, *args):
        """
        deleteConfigGroup(CMMCore self, char const * groupName)

        Parameters:
            groupName: char const *

        """
        return _MMCorePy.CMMCore_deleteConfigGroup(self, *args)

    def renameConfigGroup(self, *args):
        """
        renameConfigGroup(CMMCore self, char const * oldGroupName, char const * newGroupName)

        Parameters:
            oldGroupName: char const *
            newGroupName: char const *

        """
        return _MMCorePy.CMMCore_renameConfigGroup(self, *args)

    def isGroupDefined(self, *args):
        """
        isGroupDefined(CMMCore self, char const * groupName) -> bool

        Parameters:
            groupName: char const *

        """
        return _MMCorePy.CMMCore_isGroupDefined(self, *args)

    def isConfigDefined(self, *args):
        """
        isConfigDefined(CMMCore self, char const * groupName, char const * configName) -> bool

        Parameters:
            groupName: char const *
            configName: char const *

        """
        return _MMCorePy.CMMCore_isConfigDefined(self, *args)

    def setConfig(self, *args):
        """
        setConfig(CMMCore self, char const * groupName, char const * configName)

        Parameters:
            groupName: char const *
            configName: char const *

        """
        return _MMCorePy.CMMCore_setConfig(self, *args)

    def deleteConfig(self, *args):
        """
        deleteConfig(CMMCore self, char const * groupName, char const * configName)

        Parameters:
            groupName: char const *
            configName: char const *

        deleteConfig(CMMCore self, char const * groupName, char const * configName, char const * deviceLabel, char const * propName)

        Parameters:
            groupName: char const *
            configName: char const *
            deviceLabel: char const *
            propName: char const *

        """
        return _MMCorePy.CMMCore_deleteConfig(self, *args)

    def renameConfig(self, *args):
        """
        renameConfig(CMMCore self, char const * groupName, char const * oldConfigName, char const * newConfigName)

        Parameters:
            groupName: char const *
            oldConfigName: char const *
            newConfigName: char const *

        """
        return _MMCorePy.CMMCore_renameConfig(self, *args)

    def getAvailableConfigGroups(self):
        """
        getAvailableConfigGroups(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getAvailableConfigGroups(self)

    def getAvailableConfigs(self, *args):
        """
        getAvailableConfigs(CMMCore self, char const * configGroup) -> StrVector

        Parameters:
            configGroup: char const *

        """
        return _MMCorePy.CMMCore_getAvailableConfigs(self, *args)

    def getCurrentConfig(self, *args):
        """
        getCurrentConfig(CMMCore self, char const * groupName) -> std::string

        Parameters:
            groupName: char const *

        """
        return _MMCorePy.CMMCore_getCurrentConfig(self, *args)

    def getConfigData(self, *args):
        """
        getConfigData(CMMCore self, char const * configGroup, char const * configName) -> Configuration

        Parameters:
            configGroup: char const *
            configName: char const *

        """
        return _MMCorePy.CMMCore_getConfigData(self, *args)

    def getCurrentPixelSizeConfig(self, *args):
        """
        getCurrentPixelSizeConfig(CMMCore self) -> std::string
        getCurrentPixelSizeConfig(CMMCore self, bool cached) -> std::string

        Parameters:
            cached: bool

        """
        return _MMCorePy.CMMCore_getCurrentPixelSizeConfig(self, *args)

    def getPixelSizeUm(self, *args):
        """
        getPixelSizeUm(CMMCore self) -> double
        getPixelSizeUm(CMMCore self, bool cached) -> double

        Parameters:
            cached: bool

        """
        return _MMCorePy.CMMCore_getPixelSizeUm(self, *args)

    def getPixelSizeUmByID(self, *args):
        """
        getPixelSizeUmByID(CMMCore self, char const * resolutionID) -> double

        Parameters:
            resolutionID: char const *

        """
        return _MMCorePy.CMMCore_getPixelSizeUmByID(self, *args)

    def getMagnificationFactor(self):
        """
        getMagnificationFactor(CMMCore self) -> double

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getMagnificationFactor(self)

    def setPixelSizeUm(self, *args):
        """
        setPixelSizeUm(CMMCore self, char const * resolutionID, double pixSize)

        Parameters:
            resolutionID: char const *
            pixSize: double

        """
        return _MMCorePy.CMMCore_setPixelSizeUm(self, *args)

    def definePixelSizeConfig(self, *args):
        """
        definePixelSizeConfig(CMMCore self, char const * resolutionID, char const * deviceLabel, char const * propName, char const * value)

        Parameters:
            resolutionID: char const *
            deviceLabel: char const *
            propName: char const *
            value: char const *

        definePixelSizeConfig(CMMCore self, char const * resolutionID)

        Parameters:
            resolutionID: char const *

        """
        return _MMCorePy.CMMCore_definePixelSizeConfig(self, *args)

    def getAvailablePixelSizeConfigs(self):
        """
        getAvailablePixelSizeConfigs(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getAvailablePixelSizeConfigs(self)

    def isPixelSizeConfigDefined(self, *args):
        """
        isPixelSizeConfigDefined(CMMCore self, char const * resolutionID) -> bool

        Parameters:
            resolutionID: char const *

        """
        return _MMCorePy.CMMCore_isPixelSizeConfigDefined(self, *args)

    def setPixelSizeConfig(self, *args):
        """
        setPixelSizeConfig(CMMCore self, char const * resolutionID)

        Parameters:
            resolutionID: char const *

        """
        return _MMCorePy.CMMCore_setPixelSizeConfig(self, *args)

    def renamePixelSizeConfig(self, *args):
        """
        renamePixelSizeConfig(CMMCore self, char const * oldConfigName, char const * newConfigName)

        Parameters:
            oldConfigName: char const *
            newConfigName: char const *

        """
        return _MMCorePy.CMMCore_renamePixelSizeConfig(self, *args)

    def deletePixelSizeConfig(self, *args):
        """
        deletePixelSizeConfig(CMMCore self, char const * configName)

        Parameters:
            configName: char const *

        """
        return _MMCorePy.CMMCore_deletePixelSizeConfig(self, *args)

    def getPixelSizeConfigData(self, *args):
        """
        getPixelSizeConfigData(CMMCore self, char const * configName) -> Configuration

        Parameters:
            configName: char const *

        """
        return _MMCorePy.CMMCore_getPixelSizeConfigData(self, *args)

    def definePropertyBlock(self, *args):
        """
        definePropertyBlock(CMMCore self, char const * blockName, char const * propertyName, char const * propertyValue)

        Parameters:
            blockName: char const *
            propertyName: char const *
            propertyValue: char const *

        """
        return _MMCorePy.CMMCore_definePropertyBlock(self, *args)

    def getAvailablePropertyBlocks(self):
        """
        getAvailablePropertyBlocks(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getAvailablePropertyBlocks(self)

    def getPropertyBlockData(self, *args):
        """
        getPropertyBlockData(CMMCore self, char const * blockName) -> PropertyBlock

        Parameters:
            blockName: char const *

        """
        return _MMCorePy.CMMCore_getPropertyBlockData(self, *args)

    def setROI(self, *args):
        """
        setROI(CMMCore self, int x, int y, int xSize, int ySize)

        Parameters:
            x: int
            y: int
            xSize: int
            ySize: int

        """
        return _MMCorePy.CMMCore_setROI(self, *args)

    def getROI(self, *args):
        """
        getROI(CMMCore self)
        getROI(CMMCore self, char const * label)

        Parameters:
            label: char const *

        """
        return _MMCorePy.CMMCore_getROI(self, *args)

    def clearROI(self):
        """
        clearROI(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_clearROI(self)

    def setExposure(self, *args):
        """
        setExposure(CMMCore self, double exp)

        Parameters:
            exp: double

        setExposure(CMMCore self, char const * cameraLabel, double dExp)

        Parameters:
            cameraLabel: char const *
            dExp: double

        """
        return _MMCorePy.CMMCore_setExposure(self, *args)

    def getExposure(self):
        """
        getExposure(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getExposure(self)

    def snapImage(self):
        """
        snapImage(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_snapImage(self)

    def getImage(self, *args):
        """
        getImage(CMMCore self)
        getImage(CMMCore self, unsigned int numChannel) -> void *

        Parameters:
            numChannel: unsigned int

        """
        return _MMCorePy.CMMCore_getImage(self, *args)

    def getImageWidth(self):
        """
        getImageWidth(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getImageWidth(self)

    def getImageHeight(self):
        """
        getImageHeight(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getImageHeight(self)

    def getBytesPerPixel(self):
        """
        getBytesPerPixel(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getBytesPerPixel(self)

    def getImageBitDepth(self):
        """
        getImageBitDepth(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getImageBitDepth(self)

    def getNumberOfComponents(self):
        """
        getNumberOfComponents(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getNumberOfComponents(self)

    def getNumberOfCameraChannels(self):
        """
        getNumberOfCameraChannels(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getNumberOfCameraChannels(self)

    def getCameraChannelName(self, *args):
        """
        getCameraChannelName(CMMCore self, unsigned int channelNr) -> std::string

        Parameters:
            channelNr: unsigned int

        """
        return _MMCorePy.CMMCore_getCameraChannelName(self, *args)

    def getImageBufferSize(self):
        """
        getImageBufferSize(CMMCore self) -> long

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getImageBufferSize(self)

    def assignImageSynchro(self, *args):
        """
        assignImageSynchro(CMMCore self, char const * deviceLabel)

        Parameters:
            deviceLabel: char const *

        """
        return _MMCorePy.CMMCore_assignImageSynchro(self, *args)

    def removeImageSynchro(self, *args):
        """
        removeImageSynchro(CMMCore self, char const * deviceLabel)

        Parameters:
            deviceLabel: char const *

        """
        return _MMCorePy.CMMCore_removeImageSynchro(self, *args)

    def removeImageSynchroAll(self):
        """
        removeImageSynchroAll(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_removeImageSynchroAll(self)

    def setAutoShutter(self, *args):
        """
        setAutoShutter(CMMCore self, bool state)

        Parameters:
            state: bool

        """
        return _MMCorePy.CMMCore_setAutoShutter(self, *args)

    def getAutoShutter(self):
        """
        getAutoShutter(CMMCore self) -> bool

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getAutoShutter(self)

    def setShutterOpen(self, *args):
        """
        setShutterOpen(CMMCore self, bool state)

        Parameters:
            state: bool

        setShutterOpen(CMMCore self, char const * shutterLabel, bool state)

        Parameters:
            shutterLabel: char const *
            state: bool

        """
        return _MMCorePy.CMMCore_setShutterOpen(self, *args)

    def getShutterOpen(self, *args):
        """
        getShutterOpen(CMMCore self) -> bool
        getShutterOpen(CMMCore self, char const * shutterLabel) -> bool

        Parameters:
            shutterLabel: char const *

        """
        return _MMCorePy.CMMCore_getShutterOpen(self, *args)

    def startSequenceAcquisition(self, *args):
        """
        startSequenceAcquisition(CMMCore self, long numImages, double intervalMs, bool stopOnOverflow)

        Parameters:
            numImages: long
            intervalMs: double
            stopOnOverflow: bool

        startSequenceAcquisition(CMMCore self, char const * cameraLabel, long numImages, double intervalMs, bool stopOnOverflow)

        Parameters:
            cameraLabel: char const *
            numImages: long
            intervalMs: double
            stopOnOverflow: bool

        """
        return _MMCorePy.CMMCore_startSequenceAcquisition(self, *args)

    def prepareSequenceAcquisition(self, *args):
        """
        prepareSequenceAcquisition(CMMCore self, char const * cameraLabel)

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_prepareSequenceAcquisition(self, *args)

    def startContinuousSequenceAcquisition(self, *args):
        """
        startContinuousSequenceAcquisition(CMMCore self, double intervalMs)

        Parameters:
            intervalMs: double

        """
        return _MMCorePy.CMMCore_startContinuousSequenceAcquisition(self, *args)

    def stopSequenceAcquisition(self, *args):
        """
        stopSequenceAcquisition(CMMCore self)
        stopSequenceAcquisition(CMMCore self, char const * cameraLabel)

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_stopSequenceAcquisition(self, *args)

    def isSequenceRunning(self, *args):
        """
        isSequenceRunning(CMMCore self) -> bool
        isSequenceRunning(CMMCore self, char const * cameraLabel) -> bool

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_isSequenceRunning(self, *args)

    def getLastImage(self):
        """
        getLastImage(CMMCore self) -> void *

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getLastImage(self)

    def popNextImage(self):
        """
        popNextImage(CMMCore self) -> void *

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_popNextImage(self)

    def getLastImageMD(self, *args):
        """
        getLastImageMD(CMMCore self, unsigned int channel, unsigned int slice, Metadata md)

        Parameters:
            channel: unsigned int
            slice: unsigned int
            md: Metadata &

        getLastImageMD(CMMCore self, Metadata md) -> void *

        Parameters:
            md: Metadata &

        """
        return _MMCorePy.CMMCore_getLastImageMD(self, *args)

    def getNBeforeLastImageMD(self, *args):
        """
        getNBeforeLastImageMD(CMMCore self, unsigned long n, Metadata md) -> void *

        Parameters:
            n: unsigned long
            md: Metadata &

        """
        return _MMCorePy.CMMCore_getNBeforeLastImageMD(self, *args)

    def popNextImageMD(self, *args):
        """
        popNextImageMD(CMMCore self, unsigned int channel, unsigned int slice, Metadata md)

        Parameters:
            channel: unsigned int
            slice: unsigned int
            md: Metadata &

        popNextImageMD(CMMCore self, Metadata md) -> void *

        Parameters:
            md: Metadata &

        """
        return _MMCorePy.CMMCore_popNextImageMD(self, *args)

    def getRemainingImageCount(self):
        """
        getRemainingImageCount(CMMCore self) -> long

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getRemainingImageCount(self)

    def getBufferTotalCapacity(self):
        """
        getBufferTotalCapacity(CMMCore self) -> long

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getBufferTotalCapacity(self)

    def getBufferFreeCapacity(self):
        """
        getBufferFreeCapacity(CMMCore self) -> long

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getBufferFreeCapacity(self)

    def isBufferOverflowed(self):
        """
        isBufferOverflowed(CMMCore self) -> bool

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_isBufferOverflowed(self)

    def setCircularBufferMemoryFootprint(self, *args):
        """
        setCircularBufferMemoryFootprint(CMMCore self, unsigned int sizeMB)

        Parameters:
            sizeMB: unsigned int

        """
        return _MMCorePy.CMMCore_setCircularBufferMemoryFootprint(self, *args)

    def getCircularBufferMemoryFootprint(self):
        """
        getCircularBufferMemoryFootprint(CMMCore self) -> unsigned int

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getCircularBufferMemoryFootprint(self)

    def initializeCircularBuffer(self):
        """
        initializeCircularBuffer(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_initializeCircularBuffer(self)

    def clearCircularBuffer(self):
        """
        clearCircularBuffer(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_clearCircularBuffer(self)

    def isExposureSequenceable(self, *args):
        """
        isExposureSequenceable(CMMCore self, char const * cameraLabel) -> bool

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_isExposureSequenceable(self, *args)

    def startExposureSequence(self, *args):
        """
        startExposureSequence(CMMCore self, char const * cameraLabel)

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_startExposureSequence(self, *args)

    def stopExposureSequence(self, *args):
        """
        stopExposureSequence(CMMCore self, char const * cameraLabel)

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_stopExposureSequence(self, *args)

    def getExposureSequenceMaxLength(self, *args):
        """
        getExposureSequenceMaxLength(CMMCore self, char const * cameraLabel) -> long

        Parameters:
            cameraLabel: char const *

        """
        return _MMCorePy.CMMCore_getExposureSequenceMaxLength(self, *args)

    def loadExposureSequence(self, *args):
        """
        loadExposureSequence(CMMCore self, char const * cameraLabel, std::vector< double,std::allocator< double > > exposureSequence_ms)

        Parameters:
            cameraLabel: char const *
            exposureSequence_ms: std::vector< double,std::allocator< double > >

        """
        return _MMCorePy.CMMCore_loadExposureSequence(self, *args)

    def getLastFocusScore(self):
        """
        getLastFocusScore(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getLastFocusScore(self)

    def getCurrentFocusScore(self):
        """
        getCurrentFocusScore(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getCurrentFocusScore(self)

    def enableContinuousFocus(self, *args):
        """
        enableContinuousFocus(CMMCore self, bool enable)

        Parameters:
            enable: bool

        """
        return _MMCorePy.CMMCore_enableContinuousFocus(self, *args)

    def isContinuousFocusEnabled(self):
        """
        isContinuousFocusEnabled(CMMCore self) -> bool

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_isContinuousFocusEnabled(self)

    def isContinuousFocusLocked(self):
        """
        isContinuousFocusLocked(CMMCore self) -> bool

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_isContinuousFocusLocked(self)

    def isContinuousFocusDrive(self, *args):
        """
        isContinuousFocusDrive(CMMCore self, char const * stageLabel) -> bool

        Parameters:
            stageLabel: char const *

        """
        return _MMCorePy.CMMCore_isContinuousFocusDrive(self, *args)

    def fullFocus(self):
        """
        fullFocus(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_fullFocus(self)

    def incrementalFocus(self):
        """
        incrementalFocus(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_incrementalFocus(self)

    def setAutoFocusOffset(self, *args):
        """
        setAutoFocusOffset(CMMCore self, double offset)

        Parameters:
            offset: double

        """
        return _MMCorePy.CMMCore_setAutoFocusOffset(self, *args)

    def getAutoFocusOffset(self):
        """
        getAutoFocusOffset(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getAutoFocusOffset(self)

    def setState(self, *args):
        """
        setState(CMMCore self, char const * stateDeviceLabel, long state)

        Parameters:
            stateDeviceLabel: char const *
            state: long

        """
        return _MMCorePy.CMMCore_setState(self, *args)

    def getState(self, *args):
        """
        getState(CMMCore self, char const * stateDeviceLabel) -> long

        Parameters:
            stateDeviceLabel: char const *

        """
        return _MMCorePy.CMMCore_getState(self, *args)

    def getNumberOfStates(self, *args):
        """
        getNumberOfStates(CMMCore self, char const * stateDeviceLabel) -> long

        Parameters:
            stateDeviceLabel: char const *

        """
        return _MMCorePy.CMMCore_getNumberOfStates(self, *args)

    def setStateLabel(self, *args):
        """
        setStateLabel(CMMCore self, char const * stateDeviceLabel, char const * stateLabel)

        Parameters:
            stateDeviceLabel: char const *
            stateLabel: char const *

        """
        return _MMCorePy.CMMCore_setStateLabel(self, *args)

    def getStateLabel(self, *args):
        """
        getStateLabel(CMMCore self, char const * stateDeviceLabel) -> std::string

        Parameters:
            stateDeviceLabel: char const *

        """
        return _MMCorePy.CMMCore_getStateLabel(self, *args)

    def defineStateLabel(self, *args):
        """
        defineStateLabel(CMMCore self, char const * stateDeviceLabel, long state, char const * stateLabel)

        Parameters:
            stateDeviceLabel: char const *
            state: long
            stateLabel: char const *

        """
        return _MMCorePy.CMMCore_defineStateLabel(self, *args)

    def getStateLabels(self, *args):
        """
        getStateLabels(CMMCore self, char const * stateDeviceLabel) -> StrVector

        Parameters:
            stateDeviceLabel: char const *

        """
        return _MMCorePy.CMMCore_getStateLabels(self, *args)

    def getStateFromLabel(self, *args):
        """
        getStateFromLabel(CMMCore self, char const * stateDeviceLabel, char const * stateLabel) -> long

        Parameters:
            stateDeviceLabel: char const *
            stateLabel: char const *

        """
        return _MMCorePy.CMMCore_getStateFromLabel(self, *args)

    def getStateLabelData(self, *args):
        """
        getStateLabelData(CMMCore self, char const * stateDeviceLabel, char const * stateLabel) -> PropertyBlock

        Parameters:
            stateDeviceLabel: char const *
            stateLabel: char const *

        """
        return _MMCorePy.CMMCore_getStateLabelData(self, *args)

    def getData(self, *args):
        """
        getData(CMMCore self, char const * stateDeviceLabel) -> PropertyBlock

        Parameters:
            stateDeviceLabel: char const *

        """
        return _MMCorePy.CMMCore_getData(self, *args)

    def setPosition(self, *args):
        """
        setPosition(CMMCore self, char const * stageLabel, double position)

        Parameters:
            stageLabel: char const *
            position: double

        setPosition(CMMCore self, double position)

        Parameters:
            position: double

        """
        return _MMCorePy.CMMCore_setPosition(self, *args)

    def getPosition(self, *args):
        """
        getPosition(CMMCore self, char const * stageLabel) -> double

        Parameters:
            stageLabel: char const *

        getPosition(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getPosition(self, *args)

    def setRelativePosition(self, *args):
        """
        setRelativePosition(CMMCore self, char const * stageLabel, double d)

        Parameters:
            stageLabel: char const *
            d: double

        setRelativePosition(CMMCore self, double d)

        Parameters:
            d: double

        """
        return _MMCorePy.CMMCore_setRelativePosition(self, *args)

    def setOrigin(self, *args):
        """
        setOrigin(CMMCore self, char const * stageLabel)

        Parameters:
            stageLabel: char const *

        setOrigin(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_setOrigin(self, *args)

    def setAdapterOrigin(self, *args):
        """
        setAdapterOrigin(CMMCore self, char const * stageLabel, double newZUm)

        Parameters:
            stageLabel: char const *
            newZUm: double

        setAdapterOrigin(CMMCore self, double newZUm)

        Parameters:
            newZUm: double

        """
        return _MMCorePy.CMMCore_setAdapterOrigin(self, *args)

    def setFocusDirection(self, *args):
        """
        setFocusDirection(CMMCore self, char const * stageLabel, int sign)

        Parameters:
            stageLabel: char const *
            sign: int

        """
        return _MMCorePy.CMMCore_setFocusDirection(self, *args)

    def getFocusDirection(self, *args):
        """
        getFocusDirection(CMMCore self, char const * stageLabel) -> int

        Parameters:
            stageLabel: char const *

        """
        return _MMCorePy.CMMCore_getFocusDirection(self, *args)

    def isStageSequenceable(self, *args):
        """
        isStageSequenceable(CMMCore self, char const * stageLabel) -> bool

        Parameters:
            stageLabel: char const *

        """
        return _MMCorePy.CMMCore_isStageSequenceable(self, *args)

    def startStageSequence(self, *args):
        """
        startStageSequence(CMMCore self, char const * stageLabel)

        Parameters:
            stageLabel: char const *

        """
        return _MMCorePy.CMMCore_startStageSequence(self, *args)

    def stopStageSequence(self, *args):
        """
        stopStageSequence(CMMCore self, char const * stageLabel)

        Parameters:
            stageLabel: char const *

        """
        return _MMCorePy.CMMCore_stopStageSequence(self, *args)

    def getStageSequenceMaxLength(self, *args):
        """
        getStageSequenceMaxLength(CMMCore self, char const * stageLabel) -> long

        Parameters:
            stageLabel: char const *

        """
        return _MMCorePy.CMMCore_getStageSequenceMaxLength(self, *args)

    def loadStageSequence(self, *args):
        """
        loadStageSequence(CMMCore self, char const * stageLabel, std::vector< double,std::allocator< double > > positionSequence)

        Parameters:
            stageLabel: char const *
            positionSequence: std::vector< double,std::allocator< double > >

        """
        return _MMCorePy.CMMCore_loadStageSequence(self, *args)

    def setXYPosition(self, *args):
        """
        setXYPosition(CMMCore self, char const * xyStageLabel, double x, double y)

        Parameters:
            xyStageLabel: char const *
            x: double
            y: double

        setXYPosition(CMMCore self, double x, double y)

        Parameters:
            x: double
            y: double

        """
        return _MMCorePy.CMMCore_setXYPosition(self, *args)

    def setRelativeXYPosition(self, *args):
        """
        setRelativeXYPosition(CMMCore self, char const * xyStageLabel, double dx, double dy)

        Parameters:
            xyStageLabel: char const *
            dx: double
            dy: double

        setRelativeXYPosition(CMMCore self, double dx, double dy)

        Parameters:
            dx: double
            dy: double

        """
        return _MMCorePy.CMMCore_setRelativeXYPosition(self, *args)

    def getXYPosition(self, *args):
        """
        getXYPosition(CMMCore self, char const * xyStageLabel, double & x_stage, double & y_stage)

        Parameters:
            xyStageLabel: char const *
            x_stage: double &
            y_stage: double &

        getXYPosition(CMMCore self, double & x_stage, double & y_stage)

        Parameters:
            x_stage: double &
            y_stage: double &

        """
        return _MMCorePy.CMMCore_getXYPosition(self, *args)

    def getXPosition(self, *args):
        """
        getXPosition(CMMCore self, char const * xyStageLabel) -> double

        Parameters:
            xyStageLabel: char const *

        getXPosition(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getXPosition(self, *args)

    def getYPosition(self, *args):
        """
        getYPosition(CMMCore self, char const * xyStageLabel) -> double

        Parameters:
            xyStageLabel: char const *

        getYPosition(CMMCore self) -> double

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getYPosition(self, *args)

    def stop(self, *args):
        """
        stop(CMMCore self, char const * xyOrZStageLabel)

        Parameters:
            xyOrZStageLabel: char const *

        """
        return _MMCorePy.CMMCore_stop(self, *args)

    def home(self, *args):
        """
        home(CMMCore self, char const * xyOrZStageLabel)

        Parameters:
            xyOrZStageLabel: char const *

        """
        return _MMCorePy.CMMCore_home(self, *args)

    def setOriginXY(self, *args):
        """
        setOriginXY(CMMCore self, char const * xyStageLabel)

        Parameters:
            xyStageLabel: char const *

        setOriginXY(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_setOriginXY(self, *args)

    def setOriginX(self, *args):
        """
        setOriginX(CMMCore self, char const * xyStageLabel)

        Parameters:
            xyStageLabel: char const *

        setOriginX(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_setOriginX(self, *args)

    def setOriginY(self, *args):
        """
        setOriginY(CMMCore self, char const * xyStageLabel)

        Parameters:
            xyStageLabel: char const *

        setOriginY(CMMCore self)

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_setOriginY(self, *args)

    def setAdapterOriginXY(self, *args):
        """
        setAdapterOriginXY(CMMCore self, char const * xyStageLabel, double newXUm, double newYUm)

        Parameters:
            xyStageLabel: char const *
            newXUm: double
            newYUm: double

        setAdapterOriginXY(CMMCore self, double newXUm, double newYUm)

        Parameters:
            newXUm: double
            newYUm: double

        """
        return _MMCorePy.CMMCore_setAdapterOriginXY(self, *args)

    def isXYStageSequenceable(self, *args):
        """
        isXYStageSequenceable(CMMCore self, char const * xyStageLabel) -> bool

        Parameters:
            xyStageLabel: char const *

        """
        return _MMCorePy.CMMCore_isXYStageSequenceable(self, *args)

    def startXYStageSequence(self, *args):
        """
        startXYStageSequence(CMMCore self, char const * xyStageLabel)

        Parameters:
            xyStageLabel: char const *

        """
        return _MMCorePy.CMMCore_startXYStageSequence(self, *args)

    def stopXYStageSequence(self, *args):
        """
        stopXYStageSequence(CMMCore self, char const * xyStageLabel)

        Parameters:
            xyStageLabel: char const *

        """
        return _MMCorePy.CMMCore_stopXYStageSequence(self, *args)

    def getXYStageSequenceMaxLength(self, *args):
        """
        getXYStageSequenceMaxLength(CMMCore self, char const * xyStageLabel) -> long

        Parameters:
            xyStageLabel: char const *

        """
        return _MMCorePy.CMMCore_getXYStageSequenceMaxLength(self, *args)

    def loadXYStageSequence(self, *args):
        """
        loadXYStageSequence(CMMCore self, char const * xyStageLabel, std::vector< double,std::allocator< double > > xSequence, 
            std::vector< double,std::allocator< double > > ySequence)

        Parameters:
            xyStageLabel: char const *
            xSequence: std::vector< double,std::allocator< double > >
            ySequence: std::vector< double,std::allocator< double > >

        """
        return _MMCorePy.CMMCore_loadXYStageSequence(self, *args)

    def setSerialProperties(self, *args):
        """
        setSerialProperties(CMMCore self, char const * portName, char const * answerTimeout, char const * baudRate, char const * delayBetweenCharsMs, 
            char const * handshaking, char const * parity, char const * stopBits)

        Parameters:
            portName: char const *
            answerTimeout: char const *
            baudRate: char const *
            delayBetweenCharsMs: char const *
            handshaking: char const *
            parity: char const *
            stopBits: char const *

        """
        return _MMCorePy.CMMCore_setSerialProperties(self, *args)

    def setSerialPortCommand(self, *args):
        """
        setSerialPortCommand(CMMCore self, char const * portLabel, char const * command, char const * term)

        Parameters:
            portLabel: char const *
            command: char const *
            term: char const *

        """
        return _MMCorePy.CMMCore_setSerialPortCommand(self, *args)

    def getSerialPortAnswer(self, *args):
        """
        getSerialPortAnswer(CMMCore self, char const * portLabel, char const * term) -> std::string

        Parameters:
            portLabel: char const *
            term: char const *

        """
        return _MMCorePy.CMMCore_getSerialPortAnswer(self, *args)

    def writeToSerialPort(self, *args):
        """
        writeToSerialPort(CMMCore self, char const * portLabel, CharVector data)

        Parameters:
            portLabel: char const *
            data: std::vector< char,std::allocator< char > > const &

        """
        return _MMCorePy.CMMCore_writeToSerialPort(self, *args)

    def readFromSerialPort(self, *args):
        """
        readFromSerialPort(CMMCore self, char const * portLabel) -> CharVector

        Parameters:
            portLabel: char const *

        """
        return _MMCorePy.CMMCore_readFromSerialPort(self, *args)

    def setSLMImage(self, *args):
        """
        setSLMImage(CMMCore self, char const * slmLabel, unsigned char * pixels)

        Parameters:
            slmLabel: char const *
            pixels: unsigned char *

        setSLMImage(CMMCore self, char const * slmLabel, imgRGB32 pixels)

        Parameters:
            slmLabel: char const *
            pixels: imgRGB32

        """
        return _MMCorePy.CMMCore_setSLMImage(self, *args)

    def setSLMPixelsTo(self, *args):
        """
        setSLMPixelsTo(CMMCore self, char const * slmLabel, unsigned char intensity)

        Parameters:
            slmLabel: char const *
            intensity: unsigned char

        setSLMPixelsTo(CMMCore self, char const * slmLabel, unsigned char red, unsigned char green, unsigned char blue)

        Parameters:
            slmLabel: char const *
            red: unsigned char
            green: unsigned char
            blue: unsigned char

        """
        return _MMCorePy.CMMCore_setSLMPixelsTo(self, *args)

    def displaySLMImage(self, *args):
        """
        displaySLMImage(CMMCore self, char const * slmLabel)

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_displaySLMImage(self, *args)

    def setSLMExposure(self, *args):
        """
        setSLMExposure(CMMCore self, char const * slmLabel, double exposure_ms)

        Parameters:
            slmLabel: char const *
            exposure_ms: double

        """
        return _MMCorePy.CMMCore_setSLMExposure(self, *args)

    def getSLMExposure(self, *args):
        """
        getSLMExposure(CMMCore self, char const * slmLabel) -> double

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_getSLMExposure(self, *args)

    def getSLMWidth(self, *args):
        """
        getSLMWidth(CMMCore self, char const * slmLabel) -> unsigned int

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_getSLMWidth(self, *args)

    def getSLMHeight(self, *args):
        """
        getSLMHeight(CMMCore self, char const * slmLabel) -> unsigned int

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_getSLMHeight(self, *args)

    def getSLMNumberOfComponents(self, *args):
        """
        getSLMNumberOfComponents(CMMCore self, char const * slmLabel) -> unsigned int

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_getSLMNumberOfComponents(self, *args)

    def getSLMBytesPerPixel(self, *args):
        """
        getSLMBytesPerPixel(CMMCore self, char const * slmLabel) -> unsigned int

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_getSLMBytesPerPixel(self, *args)

    def getSLMSequenceMaxLength(self, *args):
        """
        getSLMSequenceMaxLength(CMMCore self, char const * slmLabel) -> long

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_getSLMSequenceMaxLength(self, *args)

    def startSLMSequence(self, *args):
        """
        startSLMSequence(CMMCore self, char const * slmLabel)

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_startSLMSequence(self, *args)

    def stopSLMSequence(self, *args):
        """
        stopSLMSequence(CMMCore self, char const * slmLabel)

        Parameters:
            slmLabel: char const *

        """
        return _MMCorePy.CMMCore_stopSLMSequence(self, *args)

    def loadSLMSequence(self, *args):
        """
        loadSLMSequence(CMMCore self, char const * slmLabel, std::vector< unsigned char *,std::allocator< unsigned char * > > imageSequence)

        Parameters:
            slmLabel: char const *
            imageSequence: std::vector< unsigned char *,std::allocator< unsigned char * > >

        """
        return _MMCorePy.CMMCore_loadSLMSequence(self, *args)

    def pointGalvoAndFire(self, *args):
        """
        pointGalvoAndFire(CMMCore self, char const * galvoLabel, double x, double y, double pulseTime_us)

        Parameters:
            galvoLabel: char const *
            x: double
            y: double
            pulseTime_us: double

        """
        return _MMCorePy.CMMCore_pointGalvoAndFire(self, *args)

    def setGalvoSpotInterval(self, *args):
        """
        setGalvoSpotInterval(CMMCore self, char const * galvoLabel, double pulseTime_us)

        Parameters:
            galvoLabel: char const *
            pulseTime_us: double

        """
        return _MMCorePy.CMMCore_setGalvoSpotInterval(self, *args)

    def setGalvoPosition(self, *args):
        """
        setGalvoPosition(CMMCore self, char const * galvoLabel, double x, double y)

        Parameters:
            galvoLabel: char const *
            x: double
            y: double

        """
        return _MMCorePy.CMMCore_setGalvoPosition(self, *args)

    def getGalvoPosition(self, *args):
        """
        getGalvoPosition(CMMCore self, char const * galvoLabel, double & x_stage, double & y_stage)

        Parameters:
            galvoLabel: char const *
            x_stage: double &
            y_stage: double &

        """
        return _MMCorePy.CMMCore_getGalvoPosition(self, *args)

    def setGalvoIlluminationState(self, *args):
        """
        setGalvoIlluminationState(CMMCore self, char const * galvoLabel, bool on)

        Parameters:
            galvoLabel: char const *
            on: bool

        """
        return _MMCorePy.CMMCore_setGalvoIlluminationState(self, *args)

    def getGalvoXRange(self, *args):
        """
        getGalvoXRange(CMMCore self, char const * galvoLabel) -> double

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_getGalvoXRange(self, *args)

    def getGalvoXMinimum(self, *args):
        """
        getGalvoXMinimum(CMMCore self, char const * galvoLabel) -> double

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_getGalvoXMinimum(self, *args)

    def getGalvoYRange(self, *args):
        """
        getGalvoYRange(CMMCore self, char const * galvoLabel) -> double

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_getGalvoYRange(self, *args)

    def getGalvoYMinimum(self, *args):
        """
        getGalvoYMinimum(CMMCore self, char const * galvoLabel) -> double

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_getGalvoYMinimum(self, *args)

    def addGalvoPolygonVertex(self, *args):
        """
        addGalvoPolygonVertex(CMMCore self, char const * galvoLabel, int polygonIndex, double x, double y)

        Parameters:
            galvoLabel: char const *
            polygonIndex: int
            x: double
            y: double

        """
        return _MMCorePy.CMMCore_addGalvoPolygonVertex(self, *args)

    def deleteGalvoPolygons(self, *args):
        """
        deleteGalvoPolygons(CMMCore self, char const * galvoLabel)

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_deleteGalvoPolygons(self, *args)

    def loadGalvoPolygons(self, *args):
        """
        loadGalvoPolygons(CMMCore self, char const * galvoLabel)

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_loadGalvoPolygons(self, *args)

    def setGalvoPolygonRepetitions(self, *args):
        """
        setGalvoPolygonRepetitions(CMMCore self, char const * galvoLabel, int repetitions)

        Parameters:
            galvoLabel: char const *
            repetitions: int

        """
        return _MMCorePy.CMMCore_setGalvoPolygonRepetitions(self, *args)

    def runGalvoPolygons(self, *args):
        """
        runGalvoPolygons(CMMCore self, char const * galvoLabel)

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_runGalvoPolygons(self, *args)

    def runGalvoSequence(self, *args):
        """
        runGalvoSequence(CMMCore self, char const * galvoLabel)

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_runGalvoSequence(self, *args)

    def getGalvoChannel(self, *args):
        """
        getGalvoChannel(CMMCore self, char const * galvoLabel) -> std::string

        Parameters:
            galvoLabel: char const *

        """
        return _MMCorePy.CMMCore_getGalvoChannel(self, *args)

    def detectDevice(self, *args):
        """
        detectDevice(CMMCore self, char * deviceLabel) -> MM::DeviceDetectionStatus

        Parameters:
            deviceLabel: char *

        """
        return _MMCorePy.CMMCore_detectDevice(self, *args)

    def getParentLabel(self, *args):
        """
        getParentLabel(CMMCore self, char const * peripheralLabel) -> std::string

        Parameters:
            peripheralLabel: char const *

        """
        return _MMCorePy.CMMCore_getParentLabel(self, *args)

    def setParentLabel(self, *args):
        """
        setParentLabel(CMMCore self, char const * deviceLabel, char const * parentHubLabel)

        Parameters:
            deviceLabel: char const *
            parentHubLabel: char const *

        """
        return _MMCorePy.CMMCore_setParentLabel(self, *args)

    def getInstalledDevices(self, *args):
        """
        getInstalledDevices(CMMCore self, char const * hubLabel) -> StrVector

        Parameters:
            hubLabel: char const *

        """
        return _MMCorePy.CMMCore_getInstalledDevices(self, *args)

    def getInstalledDeviceDescription(self, *args):
        """
        getInstalledDeviceDescription(CMMCore self, char const * hubLabel, char const * peripheralLabel) -> std::string

        Parameters:
            hubLabel: char const *
            peripheralLabel: char const *

        """
        return _MMCorePy.CMMCore_getInstalledDeviceDescription(self, *args)

    def getLoadedPeripheralDevices(self, *args):
        """
        getLoadedPeripheralDevices(CMMCore self, char const * hubLabel) -> StrVector

        Parameters:
            hubLabel: char const *

        """
        return _MMCorePy.CMMCore_getLoadedPeripheralDevices(self, *args)

    def getUserId(self):
        """
        getUserId(CMMCore self) -> std::string

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getUserId(self)

    def getHostName(self):
        """
        getHostName(CMMCore self) -> std::string

        Parameters:
            self: CMMCore const *

        """
        return _MMCorePy.CMMCore_getHostName(self)

    def getMACAddresses(self):
        """
        getMACAddresses(CMMCore self) -> StrVector

        Parameters:
            self: CMMCore *

        """
        return _MMCorePy.CMMCore_getMACAddresses(self)

CMMCore_swigregister = _MMCorePy.CMMCore_swigregister
CMMCore_swigregister(CMMCore)

def CMMCore_noop():
  """CMMCore_noop()"""
  return _MMCorePy.CMMCore_noop()

def CMMCore_addSearchPath(*args):
  """
    CMMCore_addSearchPath(char const * path)

    Parameters:
        path: char const *

    """
  return _MMCorePy.CMMCore_addSearchPath(*args)

def CMMCore_getDeviceLibraries():
  """CMMCore_getDeviceLibraries() -> StrVector"""
  return _MMCorePy.CMMCore_getDeviceLibraries()

class MetadataError(_object):
    """Proxy of C++ MetadataError class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetadataError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MetadataError, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(MetadataError self, char const * msg) -> MetadataError

        Parameters:
            msg: char const *

        """
        this = _MMCorePy.new_MetadataError(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_MetadataError
    __del__ = lambda self : None;
    def getMsg(self):
        """
        getMsg(MetadataError self) -> std::string

        Parameters:
            self: MetadataError *

        """
        return _MMCorePy.MetadataError_getMsg(self)

MetadataError_swigregister = _MMCorePy.MetadataError_swigregister
MetadataError_swigregister(MetadataError)

class MetadataKeyError(MetadataError):
    """Proxy of C++ MetadataKeyError class"""
    __swig_setmethods__ = {}
    for _s in [MetadataError]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetadataKeyError, name, value)
    __swig_getmethods__ = {}
    for _s in [MetadataError]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MetadataKeyError, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(MetadataKeyError self) -> MetadataKeyError"""
        this = _MMCorePy.new_MetadataKeyError()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_MetadataKeyError
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(MetadataKeyError self, int n) -> std::string

        Parameters:
            n: int

        """
        return _MMCorePy.MetadataKeyError___getitem__(self, *args)

    def __str__(self):
        """
        __str__(MetadataKeyError self) -> std::string

        Parameters:
            self: MetadataKeyError *

        """
        return _MMCorePy.MetadataKeyError___str__(self)

MetadataKeyError_swigregister = _MMCorePy.MetadataKeyError_swigregister
MetadataKeyError_swigregister(MetadataKeyError)

class MetadataIndexError(MetadataError):
    """Proxy of C++ MetadataIndexError class"""
    __swig_setmethods__ = {}
    for _s in [MetadataError]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetadataIndexError, name, value)
    __swig_getmethods__ = {}
    for _s in [MetadataError]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MetadataIndexError, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(MetadataIndexError self) -> MetadataIndexError"""
        this = _MMCorePy.new_MetadataIndexError()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_MetadataIndexError
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """
        __getitem__(MetadataIndexError self, int n) -> std::string

        Parameters:
            n: int

        """
        return _MMCorePy.MetadataIndexError___getitem__(self, *args)

    def __str__(self):
        """
        __str__(MetadataIndexError self) -> std::string

        Parameters:
            self: MetadataIndexError *

        """
        return _MMCorePy.MetadataIndexError___str__(self)

MetadataIndexError_swigregister = _MMCorePy.MetadataIndexError_swigregister
MetadataIndexError_swigregister(MetadataIndexError)

class MetadataTag(_object):
    """Proxy of C++ MetadataTag class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetadataTag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MetadataTag, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _MMCorePy.delete_MetadataTag
    __del__ = lambda self : None;
    def GetDevice(self):
        """
        GetDevice(MetadataTag self) -> std::string const &

        Parameters:
            self: MetadataTag const *

        """
        return _MMCorePy.MetadataTag_GetDevice(self)

    def GetName(self):
        """
        GetName(MetadataTag self) -> std::string const &

        Parameters:
            self: MetadataTag const *

        """
        return _MMCorePy.MetadataTag_GetName(self)

    def GetQualifiedName(self):
        """
        GetQualifiedName(MetadataTag self) -> std::string const

        Parameters:
            self: MetadataTag const *

        """
        return _MMCorePy.MetadataTag_GetQualifiedName(self)

    def IsReadOnly(self):
        """
        IsReadOnly(MetadataTag self) -> bool const

        Parameters:
            self: MetadataTag const *

        """
        return _MMCorePy.MetadataTag_IsReadOnly(self)

    def SetDevice(self, *args):
        """
        SetDevice(MetadataTag self, char const * device)

        Parameters:
            device: char const *

        """
        return _MMCorePy.MetadataTag_SetDevice(self, *args)

    def SetName(self, *args):
        """
        SetName(MetadataTag self, char const * name)

        Parameters:
            name: char const *

        """
        return _MMCorePy.MetadataTag_SetName(self, *args)

    def SetReadOnly(self, *args):
        """
        SetReadOnly(MetadataTag self, bool ro)

        Parameters:
            ro: bool

        """
        return _MMCorePy.MetadataTag_SetReadOnly(self, *args)

    def ToSingleTag(self):
        """
        ToSingleTag(MetadataTag self) -> MetadataSingleTag

        Parameters:
            self: MetadataTag const *

        """
        return _MMCorePy.MetadataTag_ToSingleTag(self)

    def ToArrayTag(self):
        """
        ToArrayTag(MetadataTag self) -> MetadataArrayTag

        Parameters:
            self: MetadataTag const *

        """
        return _MMCorePy.MetadataTag_ToArrayTag(self)

    def Clone(self):
        """
        Clone(MetadataTag self) -> MetadataTag

        Parameters:
            self: MetadataTag *

        """
        return _MMCorePy.MetadataTag_Clone(self)

    def Serialize(self):
        """
        Serialize(MetadataTag self) -> std::string

        Parameters:
            self: MetadataTag *

        """
        return _MMCorePy.MetadataTag_Serialize(self)

    def Restore(self, *args):
        """
        Restore(MetadataTag self, char const * stream) -> bool

        Parameters:
            stream: char const *

        """
        return _MMCorePy.MetadataTag_Restore(self, *args)

MetadataTag_swigregister = _MMCorePy.MetadataTag_swigregister
MetadataTag_swigregister(MetadataTag)

class MetadataSingleTag(MetadataTag):
    """Proxy of C++ MetadataSingleTag class"""
    __swig_setmethods__ = {}
    for _s in [MetadataTag]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetadataSingleTag, name, value)
    __swig_getmethods__ = {}
    for _s in [MetadataTag]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MetadataSingleTag, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(MetadataSingleTag self) -> MetadataSingleTag
        __init__(MetadataSingleTag self, char const * name, char const * device, bool readOnly) -> MetadataSingleTag

        Parameters:
            name: char const *
            device: char const *
            readOnly: bool

        """
        this = _MMCorePy.new_MetadataSingleTag(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_MetadataSingleTag
    __del__ = lambda self : None;
    def GetValue(self):
        """
        GetValue(MetadataSingleTag self) -> std::string const &

        Parameters:
            self: MetadataSingleTag const *

        """
        return _MMCorePy.MetadataSingleTag_GetValue(self)

    def SetValue(self, *args):
        """
        SetValue(MetadataSingleTag self, char const * val)

        Parameters:
            val: char const *

        """
        return _MMCorePy.MetadataSingleTag_SetValue(self, *args)

    def ToSingleTag(self):
        """
        ToSingleTag(MetadataSingleTag self) -> MetadataSingleTag

        Parameters:
            self: MetadataSingleTag const *

        """
        return _MMCorePy.MetadataSingleTag_ToSingleTag(self)

    def Clone(self):
        """
        Clone(MetadataSingleTag self) -> MetadataTag

        Parameters:
            self: MetadataSingleTag *

        """
        return _MMCorePy.MetadataSingleTag_Clone(self)

    def Serialize(self):
        """
        Serialize(MetadataSingleTag self) -> std::string

        Parameters:
            self: MetadataSingleTag *

        """
        return _MMCorePy.MetadataSingleTag_Serialize(self)

    def Restore(self, *args):
        """
        Restore(MetadataSingleTag self, char const * stream) -> bool

        Parameters:
            stream: char const *

        """
        return _MMCorePy.MetadataSingleTag_Restore(self, *args)

MetadataSingleTag_swigregister = _MMCorePy.MetadataSingleTag_swigregister
MetadataSingleTag_swigregister(MetadataSingleTag)

class MetadataArrayTag(MetadataTag):
    """Proxy of C++ MetadataArrayTag class"""
    __swig_setmethods__ = {}
    for _s in [MetadataTag]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetadataArrayTag, name, value)
    __swig_getmethods__ = {}
    for _s in [MetadataTag]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MetadataArrayTag, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(MetadataArrayTag self) -> MetadataArrayTag"""
        this = _MMCorePy.new_MetadataArrayTag()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_MetadataArrayTag
    __del__ = lambda self : None;
    def ToArrayTag(self):
        """
        ToArrayTag(MetadataArrayTag self) -> MetadataArrayTag

        Parameters:
            self: MetadataArrayTag const *

        """
        return _MMCorePy.MetadataArrayTag_ToArrayTag(self)

    def AddValue(self, *args):
        """
        AddValue(MetadataArrayTag self, char const * val)

        Parameters:
            val: char const *

        """
        return _MMCorePy.MetadataArrayTag_AddValue(self, *args)

    def SetValue(self, *args):
        """
        SetValue(MetadataArrayTag self, char const * val, size_t idx)

        Parameters:
            val: char const *
            idx: size_t

        """
        return _MMCorePy.MetadataArrayTag_SetValue(self, *args)

    def GetValue(self, *args):
        """
        GetValue(MetadataArrayTag self, size_t idx) -> std::string const &

        Parameters:
            idx: size_t

        """
        return _MMCorePy.MetadataArrayTag_GetValue(self, *args)

    def GetSize(self):
        """
        GetSize(MetadataArrayTag self) -> size_t

        Parameters:
            self: MetadataArrayTag const *

        """
        return _MMCorePy.MetadataArrayTag_GetSize(self)

    def Clone(self):
        """
        Clone(MetadataArrayTag self) -> MetadataTag

        Parameters:
            self: MetadataArrayTag *

        """
        return _MMCorePy.MetadataArrayTag_Clone(self)

    def Serialize(self):
        """
        Serialize(MetadataArrayTag self) -> std::string

        Parameters:
            self: MetadataArrayTag *

        """
        return _MMCorePy.MetadataArrayTag_Serialize(self)

    def Restore(self, *args):
        """
        Restore(MetadataArrayTag self, char const * stream) -> bool

        Parameters:
            stream: char const *

        """
        return _MMCorePy.MetadataArrayTag_Restore(self, *args)

MetadataArrayTag_swigregister = _MMCorePy.MetadataArrayTag_swigregister
MetadataArrayTag_swigregister(MetadataArrayTag)

class Metadata(_object):
    """Proxy of C++ Metadata class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Metadata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Metadata, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _MMCorePy.delete_Metadata
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(Metadata self) -> Metadata
        __init__(Metadata self, Metadata original) -> Metadata

        Parameters:
            original: Metadata const &

        """
        this = _MMCorePy.new_Metadata(*args)
        try: self.this.append(this)
        except: self.this = this
    def Clear(self):
        """
        Clear(Metadata self)

        Parameters:
            self: Metadata *

        """
        return _MMCorePy.Metadata_Clear(self)

    def GetKeys(self):
        """
        GetKeys(Metadata self) -> StrVector

        Parameters:
            self: Metadata const *

        """
        return _MMCorePy.Metadata_GetKeys(self)

    def HasTag(self, *args):
        """
        HasTag(Metadata self, char const * key) -> bool

        Parameters:
            key: char const *

        """
        return _MMCorePy.Metadata_HasTag(self, *args)

    def GetSingleTag(self, *args):
        """
        GetSingleTag(Metadata self, char const * key) -> MetadataSingleTag

        Parameters:
            key: char const *

        """
        return _MMCorePy.Metadata_GetSingleTag(self, *args)

    def GetArrayTag(self, *args):
        """
        GetArrayTag(Metadata self, char const * key) -> MetadataArrayTag

        Parameters:
            key: char const *

        """
        return _MMCorePy.Metadata_GetArrayTag(self, *args)

    def SetTag(self, *args):
        """
        SetTag(Metadata self, MetadataTag tag)

        Parameters:
            tag: MetadataTag &

        """
        return _MMCorePy.Metadata_SetTag(self, *args)

    def RemoveTag(self, *args):
        """
        RemoveTag(Metadata self, char const * key)

        Parameters:
            key: char const *

        """
        return _MMCorePy.Metadata_RemoveTag(self, *args)

    def Merge(self, *args):
        """
        Merge(Metadata self, Metadata newTags)

        Parameters:
            newTags: Metadata const &

        """
        return _MMCorePy.Metadata_Merge(self, *args)

    def Serialize(self):
        """
        Serialize(Metadata self) -> std::string

        Parameters:
            self: Metadata const *

        """
        return _MMCorePy.Metadata_Serialize(self)

    def readLine(self, *args):
        """
        readLine(Metadata self, std::istringstream & iss) -> std::string

        Parameters:
            iss: std::istringstream &

        """
        return _MMCorePy.Metadata_readLine(self, *args)

    def Restore(self, *args):
        """
        Restore(Metadata self, char const * stream) -> bool

        Parameters:
            stream: char const *

        """
        return _MMCorePy.Metadata_Restore(self, *args)

    def Dump(self):
        """
        Dump(Metadata self) -> std::string

        Parameters:
            self: Metadata *

        """
        return _MMCorePy.Metadata_Dump(self)

Metadata_swigregister = _MMCorePy.Metadata_swigregister
Metadata_swigregister(Metadata)

class MMEventCallback(_object):
    """Proxy of C++ MMEventCallback class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMEventCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMEventCallback, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """
        __init__(MMEventCallback self) -> MMEventCallback

        Parameters:
            self: PyObject *

        """
        if self.__class__ == MMEventCallback:
            _self = None
        else:
            _self = self
        this = _MMCorePy.new_MMEventCallback(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _MMCorePy.delete_MMEventCallback
    __del__ = lambda self : None;
    def onPropertiesChanged(self):
        """
        onPropertiesChanged(MMEventCallback self)

        Parameters:
            self: MMEventCallback *

        """
        return _MMCorePy.MMEventCallback_onPropertiesChanged(self)

    def onPropertyChanged(self, *args):
        """
        onPropertyChanged(MMEventCallback self, char const * name, char const * propName, char const * propValue)

        Parameters:
            name: char const *
            propName: char const *
            propValue: char const *

        """
        return _MMCorePy.MMEventCallback_onPropertyChanged(self, *args)

    def onConfigGroupChanged(self, *args):
        """
        onConfigGroupChanged(MMEventCallback self, char const * groupName, char const * newConfigName)

        Parameters:
            groupName: char const *
            newConfigName: char const *

        """
        return _MMCorePy.MMEventCallback_onConfigGroupChanged(self, *args)

    def onSystemConfigurationLoaded(self):
        """
        onSystemConfigurationLoaded(MMEventCallback self)

        Parameters:
            self: MMEventCallback *

        """
        return _MMCorePy.MMEventCallback_onSystemConfigurationLoaded(self)

    def onPixelSizeChanged(self, *args):
        """
        onPixelSizeChanged(MMEventCallback self, double newPixelSizeUm)

        Parameters:
            newPixelSizeUm: double

        """
        return _MMCorePy.MMEventCallback_onPixelSizeChanged(self, *args)

    def onStagePositionChanged(self, *args):
        """
        onStagePositionChanged(MMEventCallback self, char * name, double pos)

        Parameters:
            name: char *
            pos: double

        """
        return _MMCorePy.MMEventCallback_onStagePositionChanged(self, *args)

    def onXYStagePositionChanged(self, *args):
        """
        onXYStagePositionChanged(MMEventCallback self, char * name, double xpos, double ypos)

        Parameters:
            name: char *
            xpos: double
            ypos: double

        """
        return _MMCorePy.MMEventCallback_onXYStagePositionChanged(self, *args)

    def onExposureChanged(self, *args):
        """
        onExposureChanged(MMEventCallback self, char * name, double newExposure)

        Parameters:
            name: char *
            newExposure: double

        """
        return _MMCorePy.MMEventCallback_onExposureChanged(self, *args)

    def onSLMExposureChanged(self, *args):
        """
        onSLMExposureChanged(MMEventCallback self, char * name, double newExposure)

        Parameters:
            name: char *
            newExposure: double

        """
        return _MMCorePy.MMEventCallback_onSLMExposureChanged(self, *args)

    def __disown__(self):
        self.this.disown()
        _MMCorePy.disown_MMEventCallback(self)
        return weakref_proxy(self)
MMEventCallback_swigregister = _MMCorePy.MMEventCallback_swigregister
MMEventCallback_swigregister(MMEventCallback)

# This file is compatible with both classic and new-style classes.