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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_py_interop_run')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_py_interop_run')
    _py_interop_run = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_py_interop_run', [dirname(__file__)])
        except ImportError:
            import _py_interop_run
            return _py_interop_run
        try:
            _mod = imp.load_module('_py_interop_run', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _py_interop_run = swig_import_helper()
    del swig_import_helper
else:
    import _py_interop_run
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class SwigPyIterator(_object):
    __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__ = _py_interop_run.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _py_interop_run.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _py_interop_run.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class base_exception(Exception):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, base_exception, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, base_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_base_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.base_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_base_exception
    __del__ = lambda self: None
base_exception_swigregister = _py_interop_run.base_exception_swigregister
base_exception_swigregister(base_exception)

class xml_format_exception(base_exception):
    __swig_setmethods__ = {}
    for _s in [base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, xml_format_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, xml_format_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_xml_format_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.xml_format_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_xml_format_exception
    __del__ = lambda self: None
xml_format_exception_swigregister = _py_interop_run.xml_format_exception_swigregister
xml_format_exception_swigregister(xml_format_exception)

class xml_file_not_found_exception(base_exception):
    __swig_setmethods__ = {}
    for _s in [base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, xml_file_not_found_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, xml_file_not_found_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_xml_file_not_found_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.xml_file_not_found_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_xml_file_not_found_exception
    __del__ = lambda self: None
xml_file_not_found_exception_swigregister = _py_interop_run.xml_file_not_found_exception_swigregister
xml_file_not_found_exception_swigregister(xml_file_not_found_exception)

class xml_parse_exception(xml_format_exception):
    __swig_setmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, xml_parse_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, xml_parse_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_xml_parse_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.xml_parse_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_xml_parse_exception
    __del__ = lambda self: None
xml_parse_exception_swigregister = _py_interop_run.xml_parse_exception_swigregister
xml_parse_exception_swigregister(xml_parse_exception)

class bad_xml_format_exception(xml_format_exception):
    __swig_setmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, bad_xml_format_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, bad_xml_format_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_bad_xml_format_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.bad_xml_format_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_bad_xml_format_exception
    __del__ = lambda self: None
bad_xml_format_exception_swigregister = _py_interop_run.bad_xml_format_exception_swigregister
bad_xml_format_exception_swigregister(bad_xml_format_exception)

class empty_xml_format_exception(xml_format_exception):
    __swig_setmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, empty_xml_format_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, empty_xml_format_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_empty_xml_format_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.empty_xml_format_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_empty_xml_format_exception
    __del__ = lambda self: None
empty_xml_format_exception_swigregister = _py_interop_run.empty_xml_format_exception_swigregister
empty_xml_format_exception_swigregister(empty_xml_format_exception)

class missing_xml_element_exception(xml_format_exception):
    __swig_setmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, missing_xml_element_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [xml_format_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, missing_xml_element_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_missing_xml_element_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.missing_xml_element_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_missing_xml_element_exception
    __del__ = lambda self: None
missing_xml_element_exception_swigregister = _py_interop_run.missing_xml_element_exception_swigregister
missing_xml_element_exception_swigregister(missing_xml_element_exception)

class invalid_read_exception(base_exception):
    __swig_setmethods__ = {}
    for _s in [base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, invalid_read_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, invalid_read_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_invalid_read_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.invalid_read_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_invalid_read_exception
    __del__ = lambda self: None
invalid_read_exception_swigregister = _py_interop_run.invalid_read_exception_swigregister
invalid_read_exception_swigregister(invalid_read_exception)

class invalid_tile_naming_method(base_exception):
    __swig_setmethods__ = {}
    for _s in [base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, invalid_tile_naming_method, name, value)
    __swig_getmethods__ = {}
    for _s in [base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, invalid_tile_naming_method, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_invalid_tile_naming_method(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.invalid_tile_naming_method___str__(self)
    __swig_destroy__ = _py_interop_run.delete_invalid_tile_naming_method
    __del__ = lambda self: None
invalid_tile_naming_method_swigregister = _py_interop_run.invalid_tile_naming_method_swigregister
invalid_tile_naming_method_swigregister(invalid_tile_naming_method)

class invalid_run_info_exception(base_exception):
    __swig_setmethods__ = {}
    for _s in [base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, invalid_run_info_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, invalid_run_info_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_invalid_run_info_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.invalid_run_info_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_invalid_run_info_exception
    __del__ = lambda self: None
invalid_run_info_exception_swigregister = _py_interop_run.invalid_run_info_exception_swigregister
invalid_run_info_exception_swigregister(invalid_run_info_exception)

class invalid_tile_list_exception(invalid_run_info_exception):
    __swig_setmethods__ = {}
    for _s in [invalid_run_info_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, invalid_tile_list_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [invalid_run_info_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, invalid_tile_list_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_invalid_tile_list_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.invalid_tile_list_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_invalid_tile_list_exception
    __del__ = lambda self: None
invalid_tile_list_exception_swigregister = _py_interop_run.invalid_tile_list_exception_swigregister
invalid_tile_list_exception_swigregister(invalid_tile_list_exception)

class invalid_run_info_cycle_exception(base_exception):
    __swig_setmethods__ = {}
    for _s in [base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, invalid_run_info_cycle_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, invalid_run_info_cycle_exception, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_run.new_invalid_run_info_cycle_exception(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_run.invalid_run_info_cycle_exception___str__(self)
    __swig_destroy__ = _py_interop_run.delete_invalid_run_info_cycle_exception
    __del__ = lambda self: None
invalid_run_info_cycle_exception_swigregister = _py_interop_run.invalid_run_info_cycle_exception_swigregister
invalid_run_info_cycle_exception_swigregister(invalid_run_info_cycle_exception)

class string_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.string_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.string_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.string_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.string_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.string_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.string_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.string_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.string_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.string_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.string_vector_pop(self)

    def append(self, x):
        return _py_interop_run.string_vector_append(self, x)

    def empty(self):
        return _py_interop_run.string_vector_empty(self)

    def size(self):
        return _py_interop_run.string_vector_size(self)

    def swap(self, v):
        return _py_interop_run.string_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.string_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.string_vector_rend(self)

    def clear(self):
        return _py_interop_run.string_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.string_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.string_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.string_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_string_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.string_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.string_vector_front(self)

    def back(self):
        return _py_interop_run.string_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.string_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.string_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.string_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.string_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.string_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_string_vector
    __del__ = lambda self: None
string_vector_swigregister = _py_interop_run.string_vector_swigregister
string_vector_swigregister(string_vector)

class ulong_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ulong_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ulong_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.ulong_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.ulong_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.ulong_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.ulong_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.ulong_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.ulong_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.ulong_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.ulong_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.ulong_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.ulong_vector_pop(self)

    def append(self, x):
        return _py_interop_run.ulong_vector_append(self, x)

    def empty(self):
        return _py_interop_run.ulong_vector_empty(self)

    def size(self):
        return _py_interop_run.ulong_vector_size(self)

    def swap(self, v):
        return _py_interop_run.ulong_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.ulong_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.ulong_vector_rend(self)

    def clear(self):
        return _py_interop_run.ulong_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.ulong_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.ulong_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.ulong_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_ulong_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.ulong_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.ulong_vector_front(self)

    def back(self):
        return _py_interop_run.ulong_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.ulong_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.ulong_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.ulong_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.ulong_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.ulong_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_ulong_vector
    __del__ = lambda self: None
ulong_vector_swigregister = _py_interop_run.ulong_vector_swigregister
ulong_vector_swigregister(ulong_vector)

class ushort_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ushort_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ushort_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.ushort_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.ushort_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.ushort_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.ushort_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.ushort_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.ushort_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.ushort_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.ushort_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.ushort_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.ushort_vector_pop(self)

    def append(self, x):
        return _py_interop_run.ushort_vector_append(self, x)

    def empty(self):
        return _py_interop_run.ushort_vector_empty(self)

    def size(self):
        return _py_interop_run.ushort_vector_size(self)

    def swap(self, v):
        return _py_interop_run.ushort_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.ushort_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.ushort_vector_rend(self)

    def clear(self):
        return _py_interop_run.ushort_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.ushort_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.ushort_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.ushort_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_ushort_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.ushort_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.ushort_vector_front(self)

    def back(self):
        return _py_interop_run.ushort_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.ushort_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.ushort_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.ushort_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.ushort_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.ushort_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_ushort_vector
    __del__ = lambda self: None
ushort_vector_swigregister = _py_interop_run.ushort_vector_swigregister
ushort_vector_swigregister(ushort_vector)

class uint_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, uint_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, uint_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.uint_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.uint_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.uint_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.uint_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.uint_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.uint_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.uint_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.uint_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.uint_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.uint_vector_pop(self)

    def append(self, x):
        return _py_interop_run.uint_vector_append(self, x)

    def empty(self):
        return _py_interop_run.uint_vector_empty(self)

    def size(self):
        return _py_interop_run.uint_vector_size(self)

    def swap(self, v):
        return _py_interop_run.uint_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.uint_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.uint_vector_rend(self)

    def clear(self):
        return _py_interop_run.uint_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.uint_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.uint_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.uint_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_uint_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.uint_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.uint_vector_front(self)

    def back(self):
        return _py_interop_run.uint_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.uint_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.uint_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.uint_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.uint_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.uint_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_uint_vector
    __del__ = lambda self: None
uint_vector_swigregister = _py_interop_run.uint_vector_swigregister
uint_vector_swigregister(uint_vector)

class float_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, float_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, float_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.float_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.float_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.float_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.float_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.float_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.float_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.float_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.float_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.float_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.float_vector_pop(self)

    def append(self, x):
        return _py_interop_run.float_vector_append(self, x)

    def empty(self):
        return _py_interop_run.float_vector_empty(self)

    def size(self):
        return _py_interop_run.float_vector_size(self)

    def swap(self, v):
        return _py_interop_run.float_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.float_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.float_vector_rend(self)

    def clear(self):
        return _py_interop_run.float_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.float_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.float_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.float_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_float_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.float_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.float_vector_front(self)

    def back(self):
        return _py_interop_run.float_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.float_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.float_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.float_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.float_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.float_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_float_vector
    __del__ = lambda self: None
float_vector_swigregister = _py_interop_run.float_vector_swigregister
float_vector_swigregister(float_vector)

class bool_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, bool_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, bool_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.bool_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.bool_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.bool_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.bool_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.bool_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.bool_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.bool_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.bool_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.bool_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.bool_vector_pop(self)

    def append(self, x):
        return _py_interop_run.bool_vector_append(self, x)

    def empty(self):
        return _py_interop_run.bool_vector_empty(self)

    def size(self):
        return _py_interop_run.bool_vector_size(self)

    def swap(self, v):
        return _py_interop_run.bool_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.bool_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.bool_vector_rend(self)

    def clear(self):
        return _py_interop_run.bool_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.bool_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.bool_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.bool_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_bool_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.bool_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.bool_vector_front(self)

    def back(self):
        return _py_interop_run.bool_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.bool_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.bool_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.bool_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.bool_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.bool_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_bool_vector
    __del__ = lambda self: None
bool_vector_swigregister = _py_interop_run.bool_vector_swigregister
bool_vector_swigregister(bool_vector)

class uchar_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, uchar_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, uchar_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.uchar_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.uchar_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.uchar_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.uchar_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.uchar_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.uchar_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.uchar_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.uchar_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.uchar_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.uchar_vector_pop(self)

    def append(self, x):
        return _py_interop_run.uchar_vector_append(self, x)

    def empty(self):
        return _py_interop_run.uchar_vector_empty(self)

    def size(self):
        return _py_interop_run.uchar_vector_size(self)

    def swap(self, v):
        return _py_interop_run.uchar_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.uchar_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.uchar_vector_rend(self)

    def clear(self):
        return _py_interop_run.uchar_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.uchar_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.uchar_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.uchar_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_uchar_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.uchar_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.uchar_vector_front(self)

    def back(self):
        return _py_interop_run.uchar_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.uchar_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.uchar_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.uchar_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.uchar_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.uchar_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_uchar_vector
    __del__ = lambda self: None
uchar_vector_swigregister = _py_interop_run.uchar_vector_swigregister
uchar_vector_swigregister(uchar_vector)


def library_version():
    return _py_interop_run.library_version()
library_version = _py_interop_run.library_version
INTEROP_UNKNOWN = _py_interop_run.INTEROP_UNKNOWN
Unknown = _py_interop_run.Unknown
Intensity = _py_interop_run.Intensity
FWHM = _py_interop_run.FWHM
BasePercent = _py_interop_run.BasePercent
PercentNoCall = _py_interop_run.PercentNoCall
Q20Percent = _py_interop_run.Q20Percent
Q30Percent = _py_interop_run.Q30Percent
AccumPercentQ20 = _py_interop_run.AccumPercentQ20
AccumPercentQ30 = _py_interop_run.AccumPercentQ30
QScore = _py_interop_run.QScore
Clusters = _py_interop_run.Clusters
ClustersPF = _py_interop_run.ClustersPF
ClusterCount = _py_interop_run.ClusterCount
ClusterCountPF = _py_interop_run.ClusterCountPF
ErrorRate = _py_interop_run.ErrorRate
PercentPhasing = _py_interop_run.PercentPhasing
PercentPrephasing = _py_interop_run.PercentPrephasing
PercentAligned = _py_interop_run.PercentAligned
Phasing = _py_interop_run.Phasing
PrePhasing = _py_interop_run.PrePhasing
CorrectedIntensity = _py_interop_run.CorrectedIntensity
CalledIntensity = _py_interop_run.CalledIntensity
SignalToNoise = _py_interop_run.SignalToNoise
OccupiedCountK = _py_interop_run.OccupiedCountK
PercentOccupied = _py_interop_run.PercentOccupied
PercentPF = _py_interop_run.PercentPF
MetricTypeCount = _py_interop_run.MetricTypeCount
UnknownMetricType = _py_interop_run.UnknownMetricType
CorrectedInt = _py_interop_run.CorrectedInt
Error = _py_interop_run.Error
Extraction = _py_interop_run.Extraction
Image = _py_interop_run.Image
Index = _py_interop_run.Index
Q = _py_interop_run.Q
Tile = _py_interop_run.Tile
QByLane = _py_interop_run.QByLane
QCollapsed = _py_interop_run.QCollapsed
EmpiricalPhasing = _py_interop_run.EmpiricalPhasing
DynamicPhasing = _py_interop_run.DynamicPhasing
ExtendedTile = _py_interop_run.ExtendedTile
MetricCount = _py_interop_run.MetricCount
UnknownMetricGroup = _py_interop_run.UnknownMetricGroup
FourDigit = _py_interop_run.FourDigit
FiveDigit = _py_interop_run.FiveDigit
Absolute = _py_interop_run.Absolute
TileNamingMethodCount = _py_interop_run.TileNamingMethodCount
UnknownTileNamingMethod = _py_interop_run.UnknownTileNamingMethod
NC = _py_interop_run.NC
A = _py_interop_run.A
C = _py_interop_run.C
G = _py_interop_run.G
T = _py_interop_run.T
NUM_OF_BASES = _py_interop_run.NUM_OF_BASES
NUM_OF_BASES_AND_NC = _py_interop_run.NUM_OF_BASES_AND_NC
UnknownBase = _py_interop_run.UnknownBase
SentinelSurface = _py_interop_run.SentinelSurface
Top = _py_interop_run.Top
Bottom = _py_interop_run.Bottom
UnknownSurface = _py_interop_run.UnknownSurface
HiSeq = _py_interop_run.HiSeq
HiScan = _py_interop_run.HiScan
MiSeq = _py_interop_run.MiSeq
NextSeq = _py_interop_run.NextSeq
MiniSeq = _py_interop_run.MiniSeq
NovaSeq = _py_interop_run.NovaSeq
iSeq = _py_interop_run.iSeq
InstrumentCount = _py_interop_run.InstrumentCount
UnknownInstrument = _py_interop_run.UnknownInstrument
BaseTileType = _py_interop_run.BaseTileType
BaseCycleType = _py_interop_run.BaseCycleType
BaseReadType = _py_interop_run.BaseReadType
BaseLaneType = _py_interop_run.BaseLaneType
BaseMetricCount = _py_interop_run.BaseMetricCount
UnknownBaseType = _py_interop_run.UnknownBaseType
Red = _py_interop_run.Red
Green = _py_interop_run.Green
Blue = _py_interop_run.Blue
Black = _py_interop_run.Black
PlotColorCount = _py_interop_run.PlotColorCount
UnknownColor = _py_interop_run.UnknownColor
Centered = _py_interop_run.Centered
Shifted = _py_interop_run.Shifted
UnknownBarPlotOption = _py_interop_run.UnknownBarPlotOption
IdType = _py_interop_run.IdType
ValueType = _py_interop_run.ValueType
StructType = _py_interop_run.StructType
ChannelArray = _py_interop_run.ChannelArray
BaseArray = _py_interop_run.BaseArray
MetricDataCount = _py_interop_run.MetricDataCount
UnknownMetricData = _py_interop_run.UnknownMetricData
TileFeature = _py_interop_run.TileFeature
CycleFeature = _py_interop_run.CycleFeature
ReadFeature = _py_interop_run.ReadFeature
BaseFeature = _py_interop_run.BaseFeature
ChannelFeature = _py_interop_run.ChannelFeature
LaneFeature = _py_interop_run.LaneFeature
UnknownMetricFeature = _py_interop_run.UnknownMetricFeature
FlowcellPlot = _py_interop_run.FlowcellPlot
ByCyclePlot = _py_interop_run.ByCyclePlot
ByLanePlot = _py_interop_run.ByLanePlot
QHistogramPlot = _py_interop_run.QHistogramPlot
QHeatmapPlot = _py_interop_run.QHeatmapPlot
SampleQCPlot = _py_interop_run.SampleQCPlot
UnknownPlotType = _py_interop_run.UnknownPlotType
class cycle_range(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cycle_range, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cycle_range, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _py_interop_run.new_cycle_range(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def first_cycle(self, *args):
        return _py_interop_run.cycle_range_first_cycle(self, *args)

    def last_cycle(self, *args):
        return _py_interop_run.cycle_range_last_cycle(self, *args)

    def empty(self):
        return _py_interop_run.cycle_range_empty(self)

    def update(self, *args):
        return _py_interop_run.cycle_range_update(self, *args)
    __swig_destroy__ = _py_interop_run.delete_cycle_range
    __del__ = lambda self: None
cycle_range_swigregister = _py_interop_run.cycle_range_swigregister
cycle_range_swigregister(cycle_range)

def subtract(lhs, first_cycle_of_read):
    return _py_interop_run.subtract(lhs, first_cycle_of_read)
subtract = _py_interop_run.subtract

class read_info(cycle_range):
    __swig_setmethods__ = {}
    for _s in [cycle_range]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, read_info, name, value)
    __swig_getmethods__ = {}
    for _s in [cycle_range]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, read_info, name)
    __repr__ = _swig_repr

    def __init__(self, number=0, first_cycle=0, last_cycle=0, is_index=False):
        this = _py_interop_run.new_read_info(number, first_cycle, last_cycle, is_index)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def number(self):
        return _py_interop_run.read_info_number(self)

    def is_index(self):
        return _py_interop_run.read_info_is_index(self)

    def total_cycles(self):
        return _py_interop_run.read_info_total_cycles(self)

    def useable_cycles(self):
        return _py_interop_run.read_info_useable_cycles(self)
    __swig_destroy__ = _py_interop_run.delete_read_info
    __del__ = lambda self: None
read_info_swigregister = _py_interop_run.read_info_swigregister
read_info_swigregister(read_info)

class flowcell_layout(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, flowcell_layout, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, flowcell_layout, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _py_interop_run.new_flowcell_layout(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def total_number_of_sections(self):
        return _py_interop_run.flowcell_layout_total_number_of_sections(self)

    def naming_method(self):
        return _py_interop_run.flowcell_layout_naming_method(self)

    def tiles(self):
        return _py_interop_run.flowcell_layout_tiles(self)

    def barcode(self):
        return _py_interop_run.flowcell_layout_barcode(self)

    def total_swaths(self, all_surfaces):
        return _py_interop_run.flowcell_layout_total_swaths(self, all_surfaces)

    def tiles_per_lane(self):
        return _py_interop_run.flowcell_layout_tiles_per_lane(self)

    def total_tiles(self):
        return _py_interop_run.flowcell_layout_total_tiles(self)

    def set_naming_method(self, naming_method):
        return _py_interop_run.flowcell_layout_set_naming_method(self, naming_method)

    def lane_count(self, *args):
        return _py_interop_run.flowcell_layout_lane_count(self, *args)

    def surface_count(self, *args):
        return _py_interop_run.flowcell_layout_surface_count(self, *args)

    def swath_count(self, *args):
        return _py_interop_run.flowcell_layout_swath_count(self, *args)

    def tile_count(self, *args):
        return _py_interop_run.flowcell_layout_tile_count(self, *args)

    def sections_per_lane(self, *args):
        return _py_interop_run.flowcell_layout_sections_per_lane(self, *args)

    def lanes_per_section(self, *args):
        return _py_interop_run.flowcell_layout_lanes_per_section(self, *args)
    __swig_destroy__ = _py_interop_run.delete_flowcell_layout
    __del__ = lambda self: None
flowcell_layout_swigregister = _py_interop_run.flowcell_layout_swigregister
flowcell_layout_swigregister(flowcell_layout)

class image_dimensions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, image_dimensions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, image_dimensions, name)
    __repr__ = _swig_repr

    def __init__(self, width=0, height=0):
        this = _py_interop_run.new_image_dimensions(width, height)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def width(self):
        return _py_interop_run.image_dimensions_width(self)

    def height(self):
        return _py_interop_run.image_dimensions_height(self)
    __swig_destroy__ = _py_interop_run.delete_image_dimensions
    __del__ = lambda self: None
image_dimensions_swigregister = _py_interop_run.image_dimensions_swigregister
image_dimensions_swigregister(image_dimensions)

class info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, info, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _py_interop_run.new_info(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def validate_tiles(self):
        return _py_interop_run.info_validate_tiles(self)

    def validate(self, *args):
        return _py_interop_run.info_validate(self, *args)

    def validate_cycle(self, lane, tile, cycle, metric_name):
        return _py_interop_run.info_validate_cycle(self, lane, tile, cycle, metric_name)

    def validate_read(self, lane, tile, read, metric_name):
        return _py_interop_run.info_validate_read(self, lane, tile, read, metric_name)

    def instrument_name(self):
        return _py_interop_run.info_instrument_name(self)

    def flowcell_id(self):
        return _py_interop_run.info_flowcell_id(self)

    def run_number(self):
        return _py_interop_run.info_run_number(self)

    def name(self):
        return _py_interop_run.info_name(self)

    def date(self):
        return _py_interop_run.info_date(self)

    def version(self):
        return _py_interop_run.info_version(self)

    def dimensions_of_image(self):
        return _py_interop_run.info_dimensions_of_image(self)

    def is_indexed(self):
        return _py_interop_run.info_is_indexed(self)

    def is_paired_end(self):
        return _py_interop_run.info_is_paired_end(self)

    def is_last_cycle_of_read(self, cycle):
        return _py_interop_run.info_is_last_cycle_of_read(self, cycle)

    def cycle_within_read(self, cycle):
        return _py_interop_run.info_cycle_within_read(self, cycle)

    def read(self, *args):
        return _py_interop_run.info_read(self, *args)

    def channels(self, *args):
        return _py_interop_run.info_channels(self, *args)

    def reads(self, *args):
        return _py_interop_run.info_reads(self, *args)

    def set_naming_method(self, naming_method):
        return _py_interop_run.info_set_naming_method(self, naming_method)

    def flowcell(self, *args):
        return _py_interop_run.info_flowcell(self, *args)

    def total_cycles(self):
        return _py_interop_run.info_total_cycles(self)

    def useable_cycles(self):
        return _py_interop_run.info_useable_cycles(self)

    def read_file(self, filename):
        return _py_interop_run.info_read_file(self, filename)

    def parse(self, data):
        return _py_interop_run.info_parse(self, data)

    def write(self, filename):
        return _py_interop_run.info_write(self, filename)
    __swig_destroy__ = _py_interop_run.delete_info
    __del__ = lambda self: None
info_swigregister = _py_interop_run.info_swigregister
info_swigregister(info)

class parameters(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, parameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, parameters, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _py_interop_run.new_parameters(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def instrument_type(self):
        return _py_interop_run.parameters_instrument_type(self)

    def version(self):
        return _py_interop_run.parameters_version(self)

    def read(self, run_folder):
        return _py_interop_run.parameters_read(self, run_folder)

    def read_file(self, filename):
        return _py_interop_run.parameters_read_file(self, filename)

    def parse(self, data):
        return _py_interop_run.parameters_parse(self, data)
    __swig_destroy__ = _py_interop_run.delete_parameters
    __del__ = lambda self: None
parameters_swigregister = _py_interop_run.parameters_swigregister
parameters_swigregister(parameters)

class read_info_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, read_info_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, read_info_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_run.read_info_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_run.read_info_vector___bool__(self)

    def __len__(self):
        return _py_interop_run.read_info_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_run.read_info_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_run.read_info_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_run.read_info_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_run.read_info_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_run.read_info_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_run.read_info_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_run.read_info_vector_pop(self)

    def append(self, x):
        return _py_interop_run.read_info_vector_append(self, x)

    def empty(self):
        return _py_interop_run.read_info_vector_empty(self)

    def size(self):
        return _py_interop_run.read_info_vector_size(self)

    def swap(self, v):
        return _py_interop_run.read_info_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_run.read_info_vector_rbegin(self)

    def rend(self):
        return _py_interop_run.read_info_vector_rend(self)

    def clear(self):
        return _py_interop_run.read_info_vector_clear(self)

    def get_allocator(self):
        return _py_interop_run.read_info_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_run.read_info_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_run.read_info_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_run.new_read_info_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_run.read_info_vector_push_back(self, x)

    def front(self):
        return _py_interop_run.read_info_vector_front(self)

    def back(self):
        return _py_interop_run.read_info_vector_back(self)

    def assign(self, n, x):
        return _py_interop_run.read_info_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_run.read_info_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_run.read_info_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_run.read_info_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_run.read_info_vector_capacity(self)
    __swig_destroy__ = _py_interop_run.delete_read_info_vector
    __del__ = lambda self: None
read_info_vector_swigregister = _py_interop_run.read_info_vector_swigregister
read_info_vector_swigregister(read_info_vector)


def list_metric_type(vec, skip=0):
    return _py_interop_run.list_metric_type(vec, skip)
list_metric_type = _py_interop_run.list_metric_type

def parse_metric_type(name):
    return _py_interop_run.parse_metric_type(name)
parse_metric_type = _py_interop_run.parse_metric_type

def to_string_metric_type(value):
    return _py_interop_run.to_string_metric_type(value)
to_string_metric_type = _py_interop_run.to_string_metric_type

def list_metric_group(vec, skip=0):
    return _py_interop_run.list_metric_group(vec, skip)
list_metric_group = _py_interop_run.list_metric_group

def parse_metric_group(name):
    return _py_interop_run.parse_metric_group(name)
parse_metric_group = _py_interop_run.parse_metric_group

def to_string_metric_group(value):
    return _py_interop_run.to_string_metric_group(value)
to_string_metric_group = _py_interop_run.to_string_metric_group

def list_tile_naming_method(vec, skip=0):
    return _py_interop_run.list_tile_naming_method(vec, skip)
list_tile_naming_method = _py_interop_run.list_tile_naming_method

def parse_tile_naming_method(name):
    return _py_interop_run.parse_tile_naming_method(name)
parse_tile_naming_method = _py_interop_run.parse_tile_naming_method

def to_string_tile_naming_method(value):
    return _py_interop_run.to_string_tile_naming_method(value)
to_string_tile_naming_method = _py_interop_run.to_string_tile_naming_method

def list_dna_bases(vec, skip=0):
    return _py_interop_run.list_dna_bases(vec, skip)
list_dna_bases = _py_interop_run.list_dna_bases

def parse_dna_bases(name):
    return _py_interop_run.parse_dna_bases(name)
parse_dna_bases = _py_interop_run.parse_dna_bases

def to_string_dna_bases(value):
    return _py_interop_run.to_string_dna_bases(value)
to_string_dna_bases = _py_interop_run.to_string_dna_bases

def list_surface_type(vec, skip=0):
    return _py_interop_run.list_surface_type(vec, skip)
list_surface_type = _py_interop_run.list_surface_type

def parse_surface_type(name):
    return _py_interop_run.parse_surface_type(name)
parse_surface_type = _py_interop_run.parse_surface_type

def to_string_surface_type(value):
    return _py_interop_run.to_string_surface_type(value)
to_string_surface_type = _py_interop_run.to_string_surface_type

def list_instrument_type(vec, skip=0):
    return _py_interop_run.list_instrument_type(vec, skip)
list_instrument_type = _py_interop_run.list_instrument_type

def parse_instrument_type(name):
    return _py_interop_run.parse_instrument_type(name)
parse_instrument_type = _py_interop_run.parse_instrument_type

def to_string_instrument_type(value):
    return _py_interop_run.to_string_instrument_type(value)
to_string_instrument_type = _py_interop_run.to_string_instrument_type

def list_metric_base_type(vec, skip=0):
    return _py_interop_run.list_metric_base_type(vec, skip)
list_metric_base_type = _py_interop_run.list_metric_base_type

def parse_metric_base_type(name):
    return _py_interop_run.parse_metric_base_type(name)
parse_metric_base_type = _py_interop_run.parse_metric_base_type

def to_string_metric_base_type(value):
    return _py_interop_run.to_string_metric_base_type(value)
to_string_metric_base_type = _py_interop_run.to_string_metric_base_type

def list_plot_colors(vec, skip=0):
    return _py_interop_run.list_plot_colors(vec, skip)
list_plot_colors = _py_interop_run.list_plot_colors

def parse_plot_colors(name):
    return _py_interop_run.parse_plot_colors(name)
parse_plot_colors = _py_interop_run.parse_plot_colors

def to_string_plot_colors(value):
    return _py_interop_run.to_string_plot_colors(value)
to_string_plot_colors = _py_interop_run.to_string_plot_colors

def list_bar_plot_options(vec, skip=0):
    return _py_interop_run.list_bar_plot_options(vec, skip)
list_bar_plot_options = _py_interop_run.list_bar_plot_options

def parse_bar_plot_options(name):
    return _py_interop_run.parse_bar_plot_options(name)
parse_bar_plot_options = _py_interop_run.parse_bar_plot_options

def to_string_bar_plot_options(value):
    return _py_interop_run.to_string_bar_plot_options(value)
to_string_bar_plot_options = _py_interop_run.to_string_bar_plot_options

def list_metric_data(vec, skip=0):
    return _py_interop_run.list_metric_data(vec, skip)
list_metric_data = _py_interop_run.list_metric_data

def parse_metric_data(name):
    return _py_interop_run.parse_metric_data(name)
parse_metric_data = _py_interop_run.parse_metric_data

def to_string_metric_data(value):
    return _py_interop_run.to_string_metric_data(value)
to_string_metric_data = _py_interop_run.to_string_metric_data

def list_metric_feature_type(vec, skip=0):
    return _py_interop_run.list_metric_feature_type(vec, skip)
list_metric_feature_type = _py_interop_run.list_metric_feature_type

def parse_metric_feature_type(name):
    return _py_interop_run.parse_metric_feature_type(name)
parse_metric_feature_type = _py_interop_run.parse_metric_feature_type

def to_string_metric_feature_type(value):
    return _py_interop_run.to_string_metric_feature_type(value)
to_string_metric_feature_type = _py_interop_run.to_string_metric_feature_type
# This file is compatible with both classic and new-style classes.


