# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.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 as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pyglass
else:
    import _pyglass

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

    def value(self) -> "PyObject *":
        return _pyglass.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _pyglass.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _pyglass.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _pyglass.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _pyglass.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _pyglass.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _pyglass.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _pyglass.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _pyglass.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _pyglass.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _pyglass.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _pyglass.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _pyglass.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _pyglass.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _pyglass.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        return _pyglass.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _pyglass:
_pyglass.SwigPyIterator_swigregister(SwigPyIterator)


def exists(p: "path") -> "bool":
    return _pyglass.exists(p)
class path(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s: "std::string const &"):
        _pyglass.path_swiginit(self, _pyglass.new_path(s))

    def append(self, source: "std::string const &") -> "boost::filesystem::path &":
        return _pyglass.path_append(self, source)

    def string(self) -> "std::string":
        return _pyglass.path_string(self)

    def root_path(self) -> "boost::filesystem::path":
        return _pyglass.path_root_path(self)

    def root_name(self) -> "boost::filesystem::path":
        return _pyglass.path_root_name(self)

    def root_directory(self) -> "boost::filesystem::path":
        return _pyglass.path_root_directory(self)

    def relative_path(self) -> "boost::filesystem::path":
        return _pyglass.path_relative_path(self)

    def parent_path(self) -> "boost::filesystem::path":
        return _pyglass.path_parent_path(self)

    def filename(self) -> "boost::filesystem::path":
        return _pyglass.path_filename(self)

    def stem(self) -> "boost::filesystem::path":
        return _pyglass.path_stem(self)

    def extension(self) -> "boost::filesystem::path":
        return _pyglass.path_extension(self)

    def empty(self) -> "bool":
        return _pyglass.path_empty(self)

    def filename_is_dot(self) -> "bool":
        return _pyglass.path_filename_is_dot(self)

    def filename_is_dot_dot(self) -> "bool":
        return _pyglass.path_filename_is_dot_dot(self)

    def has_root_path(self) -> "bool":
        return _pyglass.path_has_root_path(self)

    def has_root_name(self) -> "bool":
        return _pyglass.path_has_root_name(self)

    def has_root_directory(self) -> "bool":
        return _pyglass.path_has_root_directory(self)

    def has_relative_path(self) -> "bool":
        return _pyglass.path_has_relative_path(self)

    def has_parent_path(self) -> "bool":
        return _pyglass.path_has_parent_path(self)

    def has_filename(self) -> "bool":
        return _pyglass.path_has_filename(self)

    def has_stem(self) -> "bool":
        return _pyglass.path_has_stem(self)

    def has_extension(self) -> "bool":
        return _pyglass.path_has_extension(self)

    def is_relative(self) -> "bool":
        return _pyglass.path_is_relative(self)

    def is_absolute(self) -> "bool":
        return _pyglass.path_is_absolute(self)

    def normalize(self) -> "boost::filesystem::path &":
        return _pyglass.path_normalize(self)

    def remove_leaf(self) -> "boost::filesystem::path &":
        return _pyglass.path_remove_leaf(self)

    def leaf(self) -> "boost::filesystem::path":
        return _pyglass.path_leaf(self)

    def branch_path(self) -> "boost::filesystem::path":
        return _pyglass.path_branch_path(self)

    def generic(self) -> "boost::filesystem::path":
        return _pyglass.path_generic(self)

    def has_leaf(self) -> "bool":
        return _pyglass.path_has_leaf(self)

    def has_branch_path(self) -> "bool":
        return _pyglass.path_has_branch_path(self)

    def is_complete(self) -> "bool":
        return _pyglass.path_is_complete(self)
    __swig_destroy__ = _pyglass.delete_path

# Register path in _pyglass:
_pyglass.path_swigregister(path)

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

    def GetDirectories(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.DBAccessor_GetDirectories(self)

    def __init__(self):
        _pyglass.DBAccessor_swiginit(self, _pyglass.new_DBAccessor())
    __swig_destroy__ = _pyglass.delete_DBAccessor

# Register DBAccessor in _pyglass:
_pyglass.DBAccessor_swigregister(DBAccessor)

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

    def __init__(self, s1: "int const &", s2: "int const &"):
        _pyglass.ivec2_swiginit(self, _pyglass.new_ivec2(s1, s2))
    x = property(_pyglass.ivec2_x_get, _pyglass.ivec2_x_set)
    y = property(_pyglass.ivec2_y_get, _pyglass.ivec2_y_set)
    __swig_destroy__ = _pyglass.delete_ivec2

# Register ivec2 in _pyglass:
_pyglass.ivec2_swigregister(ivec2)

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

    def __init__(self, s1: "int const &", s2: "int const &", s3: "int const &"):
        _pyglass.ivec3_swiginit(self, _pyglass.new_ivec3(s1, s2, s3))
    x = property(_pyglass.ivec3_x_get, _pyglass.ivec3_x_set)
    y = property(_pyglass.ivec3_y_get, _pyglass.ivec3_y_set)
    z = property(_pyglass.ivec3_z_get, _pyglass.ivec3_z_set)
    __swig_destroy__ = _pyglass.delete_ivec3

# Register ivec3 in _pyglass:
_pyglass.ivec3_swigregister(ivec3)

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

    def __init__(self, s1: "float const &", s2: "float const &"):
        _pyglass.vec2_swiginit(self, _pyglass.new_vec2(s1, s2))
    x = property(_pyglass.vec2_x_get, _pyglass.vec2_x_set)
    y = property(_pyglass.vec2_y_get, _pyglass.vec2_y_set)
    __swig_destroy__ = _pyglass.delete_vec2

# Register vec2 in _pyglass:
_pyglass.vec2_swigregister(vec2)

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

    def __init__(self, s1: "float const &", s2: "float const &", s3: "float const &"):
        _pyglass.vec3_swiginit(self, _pyglass.new_vec3(s1, s2, s3))
    x = property(_pyglass.vec3_x_get, _pyglass.vec3_x_set)
    y = property(_pyglass.vec3_y_get, _pyglass.vec3_y_set)
    z = property(_pyglass.vec3_z_get, _pyglass.vec3_z_set)
    __swig_destroy__ = _pyglass.delete_vec3

# Register vec3 in _pyglass:
_pyglass.vec3_swigregister(vec3)

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

    def __init__(self, s1: "float const &", s2: "float const &", s3: "float const &", s4: "float const &"):
        _pyglass.vec4_swiginit(self, _pyglass.new_vec4(s1, s2, s3, s4))
    x = property(_pyglass.vec4_x_get, _pyglass.vec4_x_set)
    y = property(_pyglass.vec4_y_get, _pyglass.vec4_y_set)
    z = property(_pyglass.vec4_z_get, _pyglass.vec4_z_set)
    w = property(_pyglass.vec4_w_get, _pyglass.vec4_w_set)
    __swig_destroy__ = _pyglass.delete_vec4

# Register vec4 in _pyglass:
_pyglass.vec4_swigregister(vec4)

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

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

    def ReadBlock(self, *args) -> "Raster":
        return _pyglass.IReader_ReadBlock(self, *args)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.IReader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.IReader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.IReader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.IReader_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.IReader_HasSupportOfArbitraryReads(self)

    def GetBytesPerVoxel(self) -> "size_t":
        return _pyglass.IReader_GetBytesPerVoxel(self)

    def GetDataSizeForBlock(self, size: "ivec3") -> "size_t":
        return _pyglass.IReader_GetDataSizeForBlock(self, size)

    def GetResolutionLayersCount(self) -> "int":
        return _pyglass.IReader_GetResolutionLayersCount(self)

    def GetSampleMagnitude(self) -> "float":
        return _pyglass.IReader_GetSampleMagnitude(self)

    def SetSampleMagnitude(self, sampleMagnitude: "float") -> "void":
        return _pyglass.IReader_SetSampleMagnitude(self, sampleMagnitude)

    def GetVoxelDimensions(self, *args) -> "glm::vec3":
        return _pyglass.IReader_GetVoxelDimensions(self, *args)

    def GetChannelNames(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.IReader_GetChannelNames(self)

    def GetIncludedChannels(self) -> "std::vector< int,std::allocator< int > >":
        return _pyglass.IReader_GetIncludedChannels(self)

    def SetIncludedChannels(self, includedChannels: "IntList") -> "void":
        return _pyglass.IReader_SetIncludedChannels(self, includedChannels)

    def GetNativeHDF5Reader(self) -> "HDF5Reader *":
        return _pyglass.IReader_GetNativeHDF5Reader(self)
    __swig_destroy__ = _pyglass.delete_IReader

# Register IReader in _pyglass:
_pyglass.IReader_swigregister(IReader)

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

    def __init__(self, *args):
        _pyglass.DataProvider_swiginit(self, _pyglass.new_DataProvider(*args))

    def Valid(self) -> "bool":
        return _pyglass.DataProvider_Valid(self)

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.DataProvider_ReadBlock(self, start, size, timepoint)

    def ReadBlockAtResolution(self, start: "ivec3", size: "ivec3", timepoint: "int", resolutionLayer: "int") -> "Raster":
        return _pyglass.DataProvider_ReadBlockAtResolution(self, start, size, timepoint, resolutionLayer)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.DataProvider_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.DataProvider_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.DataProvider_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.DataProvider_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.DataProvider_HasSupportOfArbitraryReads(self)

    def GetResolutionLayersCount(self) -> "int":
        return _pyglass.DataProvider_GetResolutionLayersCount(self)

    def GetDataSizeForBlock(self, size: "ivec3") -> "size_t":
        return _pyglass.DataProvider_GetDataSizeForBlock(self, size)

    def GetBytesPerVoxel(self) -> "size_t":
        return _pyglass.DataProvider_GetBytesPerVoxel(self)

    def GetChannelNames(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.DataProvider_GetChannelNames(self)

    def GetIncludedChannels(self) -> "std::vector< int,std::allocator< int > >":
        return _pyglass.DataProvider_GetIncludedChannels(self)

    def SetIncludedChannels(self, includedChannels: "IntList") -> "void":
        return _pyglass.DataProvider_SetIncludedChannels(self, includedChannels)

    def GetNativeHDF5Reader(self) -> "HDF5Reader *":
        return _pyglass.DataProvider_GetNativeHDF5Reader(self)

    def GetVoxelDimensions(self) -> "glm::vec3":
        return _pyglass.DataProvider_GetVoxelDimensions(self)

    def GetSampleMagnitude(self) -> "float":
        return _pyglass.DataProvider_GetSampleMagnitude(self)

    def SetSampleMagnitude(self, sampleMagnitude: "float") -> "void":
        return _pyglass.DataProvider_SetSampleMagnitude(self, sampleMagnitude)
    __swig_destroy__ = _pyglass.delete_DataProvider

    def GetReader(self) -> "IReaderPtr":
        return _pyglass.DataProvider_GetReader(self)

# Register DataProvider in _pyglass:
_pyglass.DataProvider_swigregister(DataProvider)

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

    def __init__(self, *args):
        _pyglass.DICOMFileInfo_swiginit(self, _pyglass.new_DICOMFileInfo(*args))
    __swig_destroy__ = _pyglass.delete_DICOMFileInfo

    def GetJ2kData(self, vData: "ByteList") -> "bool":
        return _pyglass.DICOMFileInfo_GetJ2kData(self, vData)

    def GetData(self, *args) -> "bool":
        return _pyglass.DICOMFileInfo_GetData(self, *args)
    m_bSigned = property(_pyglass.DICOMFileInfo_m_bSigned_get, _pyglass.DICOMFileInfo_m_bSigned_set)
    m_fBias = property(_pyglass.DICOMFileInfo_m_fBias_get, _pyglass.DICOMFileInfo_m_fBias_set)
    m_fScale = property(_pyglass.DICOMFileInfo_m_fScale_get, _pyglass.DICOMFileInfo_m_fScale_set)
    m_fWindowWidth = property(_pyglass.DICOMFileInfo_m_fWindowWidth_get, _pyglass.DICOMFileInfo_m_fWindowWidth_set)
    m_fWindowCenter = property(_pyglass.DICOMFileInfo_m_fWindowCenter_get, _pyglass.DICOMFileInfo_m_fWindowCenter_set)
    m_fSliceLocation = property(_pyglass.DICOMFileInfo_m_fSliceLocation_get, _pyglass.DICOMFileInfo_m_fSliceLocation_set)
    m_iComponentCount = property(_pyglass.DICOMFileInfo_m_iComponentCount_get, _pyglass.DICOMFileInfo_m_iComponentCount_set)
    m_iSeries = property(_pyglass.DICOMFileInfo_m_iSeries_get, _pyglass.DICOMFileInfo_m_iSeries_set)
    m_fvPatientPosition = property(_pyglass.DICOMFileInfo_m_fvPatientPosition_get, _pyglass.DICOMFileInfo_m_fvPatientPosition_set)
    m_ivSize = property(_pyglass.DICOMFileInfo_m_ivSize_get, _pyglass.DICOMFileInfo_m_ivSize_set)
    m_fvfAspect = property(_pyglass.DICOMFileInfo_m_fvfAspect_get, _pyglass.DICOMFileInfo_m_fvfAspect_set)
    m_iAllocated = property(_pyglass.DICOMFileInfo_m_iAllocated_get, _pyglass.DICOMFileInfo_m_iAllocated_set)
    m_iStored = property(_pyglass.DICOMFileInfo_m_iStored_get, _pyglass.DICOMFileInfo_m_iStored_set)
    m_iPlanarConfig = property(_pyglass.DICOMFileInfo_m_iPlanarConfig_get, _pyglass.DICOMFileInfo_m_iPlanarConfig_set)
    m_bIsBigEndian = property(_pyglass.DICOMFileInfo_m_bIsBigEndian_get, _pyglass.DICOMFileInfo_m_bIsBigEndian_set)
    m_bIsJPEGEncoded = property(_pyglass.DICOMFileInfo_m_bIsJPEGEncoded_get, _pyglass.DICOMFileInfo_m_bIsJPEGEncoded_set)
    m_isJ2K = property(_pyglass.DICOMFileInfo_m_isJ2K_get, _pyglass.DICOMFileInfo_m_isJ2K_set)
    m_strAcquDate = property(_pyglass.DICOMFileInfo_m_strAcquDate_get, _pyglass.DICOMFileInfo_m_strAcquDate_set)
    m_strAcquTime = property(_pyglass.DICOMFileInfo_m_strAcquTime_get, _pyglass.DICOMFileInfo_m_strAcquTime_set)
    m_strModality = property(_pyglass.DICOMFileInfo_m_strModality_get, _pyglass.DICOMFileInfo_m_strModality_set)
    m_strDesc = property(_pyglass.DICOMFileInfo_m_strDesc_get, _pyglass.DICOMFileInfo_m_strDesc_set)

    def SetOffsetToData(self, iOffset: "uint32_t const") -> "void":
        return _pyglass.DICOMFileInfo_SetOffsetToData(self, iOffset)
    m_strFileName = property(_pyglass.DICOMFileInfo_m_strFileName_get, _pyglass.DICOMFileInfo_m_strFileName_set)
    m_iImageIndex = property(_pyglass.DICOMFileInfo_m_iImageIndex_get, _pyglass.DICOMFileInfo_m_iImageIndex_set)
    m_hasImageIndex = property(_pyglass.DICOMFileInfo_m_hasImageIndex_get, _pyglass.DICOMFileInfo_m_hasImageIndex_set)

    def GetOffsetToData(self) -> "uint32_t":
        return _pyglass.DICOMFileInfo_GetOffsetToData(self)

    def GetDataSize(self) -> "uint32_t":
        return _pyglass.DICOMFileInfo_GetDataSize(self)
    m_iOffsetToData = property(_pyglass.DICOMFileInfo_m_iOffsetToData_get, _pyglass.DICOMFileInfo_m_iOffsetToData_set)
    m_iDataSize = property(_pyglass.DICOMFileInfo_m_iDataSize_get, _pyglass.DICOMFileInfo_m_iDataSize_set)

# Register DICOMFileInfo in _pyglass:
_pyglass.DICOMFileInfo_swigregister(DICOMFileInfo)

TYPE_AE = _pyglass.TYPE_AE
TYPE_AS = _pyglass.TYPE_AS
TYPE_AT = _pyglass.TYPE_AT
TYPE_CS = _pyglass.TYPE_CS
TYPE_DA = _pyglass.TYPE_DA
TYPE_DS = _pyglass.TYPE_DS
TYPE_DT = _pyglass.TYPE_DT
TYPE_FL = _pyglass.TYPE_FL
TYPE_FD = _pyglass.TYPE_FD
TYPE_IS = _pyglass.TYPE_IS
TYPE_LO = _pyglass.TYPE_LO
TYPE_LT = _pyglass.TYPE_LT
TYPE_OB = _pyglass.TYPE_OB
TYPE_OW = _pyglass.TYPE_OW
TYPE_OF = _pyglass.TYPE_OF
TYPE_PN = _pyglass.TYPE_PN
TYPE_SH = _pyglass.TYPE_SH
TYPE_SL = _pyglass.TYPE_SL
TYPE_SQ = _pyglass.TYPE_SQ
TYPE_SS = _pyglass.TYPE_SS
TYPE_ST = _pyglass.TYPE_ST
TYPE_TM = _pyglass.TYPE_TM
TYPE_UI = _pyglass.TYPE_UI
TYPE_UL = _pyglass.TYPE_UL
TYPE_US = _pyglass.TYPE_US
TYPE_UT = _pyglass.TYPE_UT
TYPE_UN = _pyglass.TYPE_UN
TYPE_Implicit = _pyglass.TYPE_Implicit
class DICOMReader(IReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pyglass.DICOMReader_swiginit(self, _pyglass.new_DICOMReader())
    __swig_destroy__ = _pyglass.delete_DICOMReader

    def OpenFiles(self, files: "StringList") -> "void":
        return _pyglass.DICOMReader_OpenFiles(self, files)

    def GetDICOMFileInfo(self, strFilename: "std::string const &", info: "DICOMFileInfo") -> "bool":
        return _pyglass.DICOMReader_GetDICOMFileInfo(self, strFilename, info)

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.DICOMReader_ReadBlock(self, start, size, timepoint)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.DICOMReader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.DICOMReader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.DICOMReader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.DICOMReader_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.DICOMReader_HasSupportOfArbitraryReads(self)

    def GetVoxelDimensions(self) -> "glm::vec3":
        return _pyglass.DICOMReader_GetVoxelDimensions(self)

    @staticmethod
    def RegisterDecoderCodecs() -> "void":
        return _pyglass.DICOMReader_RegisterDecoderCodecs()

    @staticmethod
    def CleanupDecoderCodecs() -> "void":
        return _pyglass.DICOMReader_CleanupDecoderCodecs()

# Register DICOMReader in _pyglass:
_pyglass.DICOMReader_swigregister(DICOMReader)

def DICOMReader_RegisterDecoderCodecs() -> "void":
    return _pyglass.DICOMReader_RegisterDecoderCodecs()

def DICOMReader_CleanupDecoderCodecs() -> "void":
    return _pyglass.DICOMReader_CleanupDecoderCodecs()


def OpenDICOMs(paths: "StringList") -> "DataProvider":
    return _pyglass.OpenDICOMs(paths)
class HDF5Reader(IReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def OpenFile(self, path: "std::string") -> "void":
        return _pyglass.HDF5Reader_OpenFile(self, path)

    def ReadBlock(self, *args) -> "Raster":
        return _pyglass.HDF5Reader_ReadBlock(self, *args)

    def ReadBlockOfChannel(self, start: "ivec3", size: "ivec3", timepoint: "int", channel: "int", resolutionLayer: "int") -> "Raster":
        return _pyglass.HDF5Reader_ReadBlockOfChannel(self, start, size, timepoint, channel, resolutionLayer)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.HDF5Reader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.HDF5Reader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.HDF5Reader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.HDF5Reader_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.HDF5Reader_HasSupportOfArbitraryReads(self)

    def GetResolutionLayersCount(self) -> "int":
        return _pyglass.HDF5Reader_GetResolutionLayersCount(self)

    def GetDataRangeUsage(self) -> "float":
        return _pyglass.HDF5Reader_GetDataRangeUsage(self)

    def GetChannelNames(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.HDF5Reader_GetChannelNames(self)

    def SetIncludedChannels(self, includedChannels: "IntList") -> "void":
        return _pyglass.HDF5Reader_SetIncludedChannels(self, includedChannels)

    def GetCounts(self) -> "std::vector< std::vector< glm::vec3,std::allocator< glm::vec3 > >,std::allocator< std::vector< glm::vec3,std::allocator< glm::vec3 > > > >":
        return _pyglass.HDF5Reader_GetCounts(self)

    def GetSWCGraph(self) -> "SWCP::Graph":
        return _pyglass.HDF5Reader_GetSWCGraph(self)

    def GetVoxelDimensions(self) -> "glm::vec3":
        return _pyglass.HDF5Reader_GetVoxelDimensions(self)

    def GetUnits(self) -> "std::string":
        return _pyglass.HDF5Reader_GetUnits(self)

    def GetNativeHDF5Reader(self) -> "HDF5Reader *":
        return _pyglass.HDF5Reader_GetNativeHDF5Reader(self)
    __swig_destroy__ = _pyglass.delete_HDF5Reader

    def __init__(self):
        _pyglass.HDF5Reader_swiginit(self, _pyglass.new_HDF5Reader())

# Register HDF5Reader in _pyglass:
_pyglass.HDF5Reader_swigregister(HDF5Reader)


def OpenHDF5(path: "std::string") -> "DataProvider":
    return _pyglass.OpenHDF5(path)
class JPEGReader(IReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pyglass.JPEGReader_swiginit(self, _pyglass.new_JPEGReader())
    __swig_destroy__ = _pyglass.delete_JPEGReader

    def OpenFiles(self, files: "StringList") -> "void":
        return _pyglass.JPEGReader_OpenFiles(self, files)

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.JPEGReader_ReadBlock(self, start, size, timepoint)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.JPEGReader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.JPEGReader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.JPEGReader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.JPEGReader_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.JPEGReader_HasSupportOfArbitraryReads(self)

# Register JPEGReader in _pyglass:
_pyglass.JPEGReader_swigregister(JPEGReader)


def OpenJPEGs(paths: "StringList") -> "DataProvider":
    return _pyglass.OpenJPEGs(paths)
class OlympusReader(IReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pyglass.OlympusReader_swiginit(self, _pyglass.new_OlympusReader())
    __swig_destroy__ = _pyglass.delete_OlympusReader

    def OpenFile(self, file: "std::string const &") -> "void":
        return _pyglass.OlympusReader_OpenFile(self, file)

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.OlympusReader_ReadBlock(self, start, size, timepoint)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.OlympusReader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.OlympusReader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.OlympusReader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.OlympusReader_GetChannelsCount(self)

    def GetChannelNames(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.OlympusReader_GetChannelNames(self)

    def SetIncludedChannels(self, includedChannels: "IntList") -> "void":
        return _pyglass.OlympusReader_SetIncludedChannels(self, includedChannels)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.OlympusReader_HasSupportOfArbitraryReads(self)

# Register OlympusReader in _pyglass:
_pyglass.OlympusReader_swigregister(OlympusReader)


def OpenOlympus(path: "std::string") -> "DataProvider":
    return _pyglass.OpenOlympus(path)
class PNGReader(IReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pyglass.PNGReader_swiginit(self, _pyglass.new_PNGReader())
    __swig_destroy__ = _pyglass.delete_PNGReader

    def OpenFiles(self, files: "StringList") -> "void":
        return _pyglass.PNGReader_OpenFiles(self, files)

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.PNGReader_ReadBlock(self, start, size, timepoint)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.PNGReader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.PNGReader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.PNGReader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.PNGReader_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.PNGReader_HasSupportOfArbitraryReads(self)

# Register PNGReader in _pyglass:
_pyglass.PNGReader_swigregister(PNGReader)


def OpenPNGs(paths: "StringList") -> "DataProvider":
    return _pyglass.OpenPNGs(paths)
class TIFFReader(IReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _pyglass.TIFFReader_swiginit(self, _pyglass.new_TIFFReader())
    __swig_destroy__ = _pyglass.delete_TIFFReader

    def OpenFile(self, filepath: "std::string const &") -> "void":
        return _pyglass.TIFFReader_OpenFile(self, filepath)

    def OpenFiles(self, files: "StringList", timeSeries: "bool") -> "void":
        return _pyglass.TIFFReader_OpenFiles(self, files, timeSeries)

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.TIFFReader_ReadBlock(self, start, size, timepoint)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.TIFFReader_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.TIFFReader_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.TIFFReader_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.TIFFReader_GetChannelsCount(self)

    def GetChannelNames(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.TIFFReader_GetChannelNames(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.TIFFReader_HasSupportOfArbitraryReads(self)

    def SetIncludedChannels(self, includedChannels: "IntList") -> "void":
        return _pyglass.TIFFReader_SetIncludedChannels(self, includedChannels)

# Register TIFFReader in _pyglass:
_pyglass.TIFFReader_swigregister(TIFFReader)


def OpenTIFFs(paths: "StringList", timeSeries: "bool") -> "DataProvider":
    return _pyglass.OpenTIFFs(paths, timeSeries)

def OpenTIFF(path: "std::string") -> "DataProvider":
    return _pyglass.OpenTIFF(path)
class ConversionDriver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _pyglass.ConversionDriver_swiginit(self, _pyglass.new_ConversionDriver(*args))
    __swig_destroy__ = _pyglass.delete_ConversionDriver

    def SetInput(self, reader: "DataProvider") -> "void":
        return _pyglass.ConversionDriver_SetInput(self, reader)

    def SetOutput(self, project: "Project") -> "void":
        return _pyglass.ConversionDriver_SetOutput(self, project)

    def Start(self) -> "void":
        return _pyglass.ConversionDriver_Start(self)

    def StartAsynchronous(self) -> "void":
        return _pyglass.ConversionDriver_StartAsynchronous(self)

    def AddTimepoint(self) -> "void":
        return _pyglass.ConversionDriver_AddTimepoint(self)

    def AddImageFragment(self, raster: "Raster", transformation: "glm::mat4 const &", frame: "int") -> "void":
        return _pyglass.ConversionDriver_AddImageFragment(self, raster, transformation, frame)

    def GetPercentage(self) -> "float":
        return _pyglass.ConversionDriver_GetPercentage(self)

    def GetElapsedTime(self) -> "float":
        return _pyglass.ConversionDriver_GetElapsedTime(self)

    def GetRemainingTime(self) -> "float":
        return _pyglass.ConversionDriver_GetRemainingTime(self)

    def GetMinimalNeededRAM(self) -> "size_t":
        return _pyglass.ConversionDriver_GetMinimalNeededRAM(self)

    def GetFreeRAM(self) -> "size_t":
        return _pyglass.ConversionDriver_GetFreeRAM(self)

    def GetRAMLimit(self) -> "size_t":
        return _pyglass.ConversionDriver_GetRAMLimit(self)

    def SetRAMLimit(self, s: "size_t") -> "void":
        return _pyglass.ConversionDriver_SetRAMLimit(self, s)

    def GetMaxBlockSize(self) -> "size_t":
        return _pyglass.ConversionDriver_GetMaxBlockSize(self)

# Register ConversionDriver in _pyglass:
_pyglass.ConversionDriver_swigregister(ConversionDriver)

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

    def __call__(self, a: "ivec3", b: "ivec3") -> "bool":
        return _pyglass.comparator___call__(self, a, b)

    def __init__(self):
        _pyglass.comparator_swiginit(self, _pyglass.new_comparator())
    __swig_destroy__ = _pyglass.delete_comparator

# Register comparator in _pyglass:
_pyglass.comparator_swigregister(comparator)


def FillTable(*args) -> "void":
    return _pyglass.FillTable(*args)
class DirectoryDescription(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Invalid = _pyglass.DirectoryDescription_Invalid
    Imaris = _pyglass.DirectoryDescription_Imaris
    DICOM = _pyglass.DirectoryDescription_DICOM
    TIFF = _pyglass.DirectoryDescription_TIFF
    PNG = _pyglass.DirectoryDescription_PNG
    JPEG = _pyglass.DirectoryDescription_JPEG
    BMP = _pyglass.DirectoryDescription_BMP
    VSI = _pyglass.DirectoryDescription_VSI
    OIR = _pyglass.DirectoryDescription_OIR
    ND2 = _pyglass.DirectoryDescription_ND2
    CZI = _pyglass.DirectoryDescription_CZI
    LIF = _pyglass.DirectoryDescription_LIF
    Null = _pyglass.DirectoryDescription_Null

    def __init__(self):
        _pyglass.DirectoryDescription_swiginit(self, _pyglass.new_DirectoryDescription())

    def InspectByReferenceFile(self, path: "std::string") -> "void":
        return _pyglass.DirectoryDescription_InspectByReferenceFile(self, path)

    def GetFileType(self) -> "DirectoryDescription::FileType":
        return _pyglass.DirectoryDescription_GetFileType(self)

    def GetTemplateString(self) -> "std::string":
        return _pyglass.DirectoryDescription_GetTemplateString(self)

    def GetKeyPosCount(self) -> "int":
        return _pyglass.DirectoryDescription_GetKeyPosCount(self)

    def SetKeyPos(self, k: "int") -> "void":
        return _pyglass.DirectoryDescription_SetKeyPos(self, k)

    def GetFileList(self) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.DirectoryDescription_GetFileList(self)

    def GetOnlyReferenceFile(self) -> "std::string":
        return _pyglass.DirectoryDescription_GetOnlyReferenceFile(self)
    __swig_destroy__ = _pyglass.delete_DirectoryDescription

# Register DirectoryDescription in _pyglass:
_pyglass.DirectoryDescription_swigregister(DirectoryDescription)

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

    def __init__(self):
        _pyglass.VolumeLibrary_swiginit(self, _pyglass.new_VolumeLibrary())

    def GetFilePath(self) -> "std::string":
        return _pyglass.VolumeLibrary_GetFilePath(self)

    def GetLibraryEntries(self) -> "std::vector< VolumeLibrary::LibraryEntry,std::allocator< VolumeLibrary::LibraryEntry > >":
        return _pyglass.VolumeLibrary_GetLibraryEntries(self)

    def GetEntry(self, name: "std::string const &") -> "VolumeLibrary::LibraryEntry":
        return _pyglass.VolumeLibrary_GetEntry(self, name)

    def GetProjectByHash(self, hash: "std::string const &") -> "VolumeLibrary::LibraryEntry":
        return _pyglass.VolumeLibrary_GetProjectByHash(self, hash)

    def GetHashByProject(self, project: "std::string const &") -> "std::string":
        return _pyglass.VolumeLibrary_GetHashByProject(self, project)

    def GetEntryFromPath(self, pathToProjectFile: "std::string const &") -> "VolumeLibrary::LibraryEntry":
        return _pyglass.VolumeLibrary_GetEntryFromPath(self, pathToProjectFile)

    def GetFolders(self, synced: "bool"=False) -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.VolumeLibrary_GetFolders(self, synced)

    def UpdateFolder(self, oldDisplayPath: "std::string const &", newDisplayPath: "std::string const &", synced: "bool"=False) -> "void":
        return _pyglass.VolumeLibrary_UpdateFolder(self, oldDisplayPath, newDisplayPath, synced)

    def AddFolder(self, newDisplayPath: "std::string const &", synced: "bool"=False, save: "bool"=True) -> "void":
        return _pyglass.VolumeLibrary_AddFolder(self, newDisplayPath, synced, save)

    def DeleteFolder(self, folderPath: "std::string const &", deleteContents: "bool const"=True, synced: "bool"=False, save: "bool"=True) -> "void":
        return _pyglass.VolumeLibrary_DeleteFolder(self, folderPath, deleteContents, synced, save)

    def HasEntry(self, name: "std::string const &") -> "bool":
        return _pyglass.VolumeLibrary_HasEntry(self, name)

    def PutEntry(self, *args) -> "void":
        return _pyglass.VolumeLibrary_PutEntry(self, *args)

    def HasProjectFile(self, pathToProjectFile: "std::string const &") -> "bool":
        return _pyglass.VolumeLibrary_HasProjectFile(self, pathToProjectFile)

    def RenameEntry(self, newName: "std::string const &", path: "std::string const &") -> "std::string":
        return _pyglass.VolumeLibrary_RenameEntry(self, newName, path)

    def DeleteEntry(self, name: "std::string const &") -> "void":
        return _pyglass.VolumeLibrary_DeleteEntry(self, name)

    def ReloadLibrary(self) -> "void":
        return _pyglass.VolumeLibrary_ReloadLibrary(self)

    def SaveLibrary(self) -> "void":
        return _pyglass.VolumeLibrary_SaveLibrary(self)

    def CreateEntryFromPath(self, *args) -> "VolumeLibrary::LibraryEntry":
        return _pyglass.VolumeLibrary_CreateEntryFromPath(self, *args)

    def SetRemoteProjectOpenedCallback(self, callback: "CSharpCallback *") -> "void":
        return _pyglass.VolumeLibrary_SetRemoteProjectOpenedCallback(self, callback)

    def TriggerRemoteProjectOpenedCallback(self, projectName: "std::string const &") -> "void":
        return _pyglass.VolumeLibrary_TriggerRemoteProjectOpenedCallback(self, projectName)
    __swig_destroy__ = _pyglass.delete_VolumeLibrary

# Register VolumeLibrary in _pyglass:
_pyglass.VolumeLibrary_swigregister(VolumeLibrary)

class LibraryEntry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NOT_SIGNED = _pyglass.LibraryEntry_NOT_SIGNED
    SIGNED = _pyglass.LibraryEntry_SIGNED
    UNKNOWN = _pyglass.LibraryEntry_UNKNOWN
    DENSE = _pyglass.LibraryEntry_DENSE
    SPARSE = _pyglass.LibraryEntry_SPARSE

    @staticmethod
    def GetTypeString(m: "VolumeLibrary::LibraryEntry::Type") -> "std::string":
        return _pyglass.LibraryEntry_GetTypeString(m)
    type = property(_pyglass.LibraryEntry_type_get, _pyglass.LibraryEntry_type_set)
    path = property(_pyglass.LibraryEntry_path_get, _pyglass.LibraryEntry_path_set)
    displayPath = property(_pyglass.LibraryEntry_displayPath_get, _pyglass.LibraryEntry_displayPath_set)
    notes = property(_pyglass.LibraryEntry_notes_get, _pyglass.LibraryEntry_notes_set)
    name = property(_pyglass.LibraryEntry_name_get, _pyglass.LibraryEntry_name_set)
    voxelSize = property(_pyglass.LibraryEntry_voxelSize_get, _pyglass.LibraryEntry_voxelSize_set)
    thumbnail = property(_pyglass.LibraryEntry_thumbnail_get, _pyglass.LibraryEntry_thumbnail_set)
    creationDate = property(_pyglass.LibraryEntry_creationDate_get, _pyglass.LibraryEntry_creationDate_set)
    dataType = property(_pyglass.LibraryEntry_dataType_get, _pyglass.LibraryEntry_dataType_set)
    isSigned = property(_pyglass.LibraryEntry_isSigned_get, _pyglass.LibraryEntry_isSigned_set)
    grade = property(_pyglass.LibraryEntry_grade_get, _pyglass.LibraryEntry_grade_set)
    mandatory = property(_pyglass.LibraryEntry_mandatory_get, _pyglass.LibraryEntry_mandatory_set)
    local = property(_pyglass.LibraryEntry_local_get, _pyglass.LibraryEntry_local_set)

    def __init__(self):
        _pyglass.LibraryEntry_swiginit(self, _pyglass.new_LibraryEntry())
    __swig_destroy__ = _pyglass.delete_LibraryEntry

# Register LibraryEntry in _pyglass:
_pyglass.LibraryEntry_swigregister(LibraryEntry)

def LibraryEntry_GetTypeString(m: "VolumeLibrary::LibraryEntry::Type") -> "std::string":
    return _pyglass.LibraryEntry_GetTypeString(m)

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

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

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.Operator_GetSize(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.Operator_GetFrameCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.Operator_GetDataType(self)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.Operator_GetChannelsCount(self)

    def HasSupportOfArbitraryReads(self) -> "bool":
        return _pyglass.Operator_HasSupportOfArbitraryReads(self)
    __swig_destroy__ = _pyglass.delete_Operator

# Register Operator in _pyglass:
_pyglass.Operator_swigregister(Operator)

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

    def __init__(self, reader: "IReaderPtr", a: "float", b: "float"):
        _pyglass.LinearTransform_swiginit(self, _pyglass.new_LinearTransform(reader, a, b))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.LinearTransform_ReadBlock(self, start, size, timepoint)
    __swig_destroy__ = _pyglass.delete_LinearTransform

# Register LinearTransform in _pyglass:
_pyglass.LinearTransform_swigregister(LinearTransform)

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

    def __init__(self, reader: "IReaderPtr"):
        _pyglass.ConvertorTo8Bit_swiginit(self, _pyglass.new_ConvertorTo8Bit(reader))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ConvertorTo8Bit_ReadBlock(self, start, size, timepoint)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.ConvertorTo8Bit_GetDataType(self)
    __swig_destroy__ = _pyglass.delete_ConvertorTo8Bit

# Register ConvertorTo8Bit in _pyglass:
_pyglass.ConvertorTo8Bit_swigregister(ConvertorTo8Bit)

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

    def __init__(self, reader: "IReaderPtr"):
        _pyglass.ConverterTo16Bit_swiginit(self, _pyglass.new_ConverterTo16Bit(reader))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ConverterTo16Bit_ReadBlock(self, start, size, timepoint)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.ConverterTo16Bit_GetDataType(self)
    __swig_destroy__ = _pyglass.delete_ConverterTo16Bit

# Register ConverterTo16Bit in _pyglass:
_pyglass.ConverterTo16Bit_swigregister(ConverterTo16Bit)

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

    def __init__(self, reader: "IReaderPtr"):
        _pyglass.ConverterToFloat_swiginit(self, _pyglass.new_ConverterToFloat(reader))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ConverterToFloat_ReadBlock(self, start, size, timepoint)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.ConverterToFloat_GetDataType(self)
    __swig_destroy__ = _pyglass.delete_ConverterToFloat

# Register ConverterToFloat in _pyglass:
_pyglass.ConverterToFloat_swigregister(ConverterToFloat)

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

    def __init__(self, primary: "IReaderPtr", secondary: "IReaderPtr"):
        _pyglass.ChannelCombiner2_swiginit(self, _pyglass.new_ChannelCombiner2(primary, secondary))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ChannelCombiner2_ReadBlock(self, start, size, timepoint)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.ChannelCombiner2_GetChannelsCount(self)
    __swig_destroy__ = _pyglass.delete_ChannelCombiner2

# Register ChannelCombiner2 in _pyglass:
_pyglass.ChannelCombiner2_swigregister(ChannelCombiner2)

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

    def __init__(self, primary: "IReaderPtr", second: "IReaderPtr", third: "IReaderPtr"):
        _pyglass.ChannelCombiner3_swiginit(self, _pyglass.new_ChannelCombiner3(primary, second, third))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ChannelCombiner3_ReadBlock(self, start, size, timepoint)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.ChannelCombiner3_GetChannelsCount(self)
    __swig_destroy__ = _pyglass.delete_ChannelCombiner3

# Register ChannelCombiner3 in _pyglass:
_pyglass.ChannelCombiner3_swigregister(ChannelCombiner3)

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

    def __init__(self, primary: "IReaderPtr", second: "IReaderPtr", third: "IReaderPtr", fourth: "IReaderPtr"):
        _pyglass.ChannelCombiner4_swiginit(self, _pyglass.new_ChannelCombiner4(primary, second, third, fourth))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ChannelCombiner4_ReadBlock(self, start, size, timepoint)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.ChannelCombiner4_GetChannelsCount(self)
    __swig_destroy__ = _pyglass.delete_ChannelCombiner4

# Register ChannelCombiner4 in _pyglass:
_pyglass.ChannelCombiner4_swigregister(ChannelCombiner4)

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

    def __init__(self, reader: "IReaderPtr", channel: "int"):
        _pyglass.ChannelExtracter_swiginit(self, _pyglass.new_ChannelExtracter(reader, channel))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ChannelExtracter_ReadBlock(self, start, size, timepoint)

    def GetChannelsCount(self) -> "ProjectIO::Channels":
        return _pyglass.ChannelExtracter_GetChannelsCount(self)
    __swig_destroy__ = _pyglass.delete_ChannelExtracter

# Register ChannelExtracter in _pyglass:
_pyglass.ChannelExtracter_swigregister(ChannelExtracter)

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

    def __init__(self, reader: "IReaderPtr"):
        _pyglass.ColorInverse_swiginit(self, _pyglass.new_ColorInverse(reader))

    def ReadBlock(self, start: "ivec3", size: "ivec3", timepoint: "int") -> "Raster":
        return _pyglass.ColorInverse_ReadBlock(self, start, size, timepoint)
    __swig_destroy__ = _pyglass.delete_ColorInverse

# Register ColorInverse in _pyglass:
_pyglass.ColorInverse_swigregister(ColorInverse)


def ConvertTo8Bit(dp: "DataProvider") -> "DataProvider":
    return _pyglass.ConvertTo8Bit(dp)

def ConvertTo16Bit(dp: "DataProvider") -> "DataProvider":
    return _pyglass.ConvertTo16Bit(dp)

def ConvertToFloat(dp: "DataProvider") -> "DataProvider":
    return _pyglass.ConvertToFloat(dp)

def Invert(dp: "DataProvider") -> "DataProvider":
    return _pyglass.Invert(dp)

def ApplyTransform(dp: "DataProvider", a: "float", b: "float") -> "DataProvider":
    return _pyglass.ApplyTransform(dp, a, b)

def Combine2(in1: "DataProvider", in2: "DataProvider") -> "DataProvider":
    return _pyglass.Combine2(in1, in2)

def Combine3(in1: "DataProvider", in2: "DataProvider", in3: "DataProvider") -> "DataProvider":
    return _pyglass.Combine3(in1, in2, in3)

def Combine4(in1: "DataProvider", in2: "DataProvider", in3: "DataProvider", in4: "DataProvider") -> "DataProvider":
    return _pyglass.Combine4(in1, in2, in3, in4)

def ExtractChannel(dp: "DataProvider", channel: "int") -> "DataProvider":
    return _pyglass.ExtractChannel(dp, channel)
MAX_KEY = _pyglass.MAX_KEY
UINT8 = _pyglass.UINT8
UINT16 = _pyglass.UINT16
UINT32 = _pyglass.UINT32
HALF_FLOAT = _pyglass.HALF_FLOAT
FLOAT = _pyglass.FLOAT
SingleChannel = _pyglass.SingleChannel
TwoChannels = _pyglass.TwoChannels
ThreeChannels = _pyglass.ThreeChannels
FourChannels = _pyglass.FourChannels
IO_VERSION = _pyglass.IO_VERSION
IO_VERSION_MASK = _pyglass.IO_VERSION_MASK
IO_FLAGS_MASK = _pyglass.IO_FLAGS_MASK
IO_SIGNED = _pyglass.IO_SIGNED
HAS_EMBEDDED_SYM = _pyglass.HAS_EMBEDDED_SYM
HAS_FULL_HASH = _pyglass.HAS_FULL_HASH
IO_SELF_SIGNED = _pyglass.IO_SELF_SIGNED
IO_INDEX_TABLE_DONE = _pyglass.IO_INDEX_TABLE_DONE
IO_MAGIC_INT_MASK = _pyglass.IO_MAGIC_INT_MASK
IO_MAGIC_INT = _pyglass.IO_MAGIC_INT
PS_INVALID = _pyglass.PS_INVALID
PS_PROJECTFILE_WAS_CREATED_BY_NEWER_VERSION_OF_SYGLASS = _pyglass.PS_PROJECTFILE_WAS_CREATED_BY_NEWER_VERSION_OF_SYGLASS
PS_CONVERSION_WAS_INTERRUPTED = _pyglass.PS_CONVERSION_WAS_INTERRUPTED
PS_CONVERTING = _pyglass.PS_CONVERTING
PS_CONVERSION_DONE = _pyglass.PS_CONVERSION_DONE
PS_VALID = _pyglass.PS_VALID

def IsAProjectFile(*args) -> "bool":
    return _pyglass.IsAProjectFile(*args)

def WasProjectFileOpened(path: "path") -> "bool":
    return _pyglass.WasProjectFileOpened(path)

def OpenProject(path: "path") -> "ProjectIO::Project":
    return _pyglass.OpenProject(path)

def CreateTestProject() -> "ProjectIO::Project":
    return _pyglass.CreateTestProject()

def GenerateKey(projectPath: "path", keyPath: "path") -> "std::string":
    return _pyglass.GenerateKey(projectPath, keyPath)

def Sign(*args) -> "bool":
    return _pyglass.Sign(*args)

def IsProjectSigned(path: "path") -> "bool":
    return _pyglass.IsProjectSigned(path)

def OpenMouselight(path: "path") -> "ProjectIO::Project":
    return _pyglass.OpenMouselight(path)

def CreateProject(path: "path", projectName: "std::string", isMaskMode: "bool"=False) -> "ProjectIO::Project":
    return _pyglass.CreateProject(path, projectName, isMaskMode)

def DataTypeAndChannelToRasterType(d: "ProjectIO::DataType", c: "ProjectIO::Channels") -> "Raster::DataType":
    return _pyglass.DataTypeAndChannelToRasterType(d, c)

def RasterTypeToDataTypeAndChannel(rd: "Raster::DataType", d: "ProjectIO::DataType &", c: "ProjectIO::Channels &") -> "void":
    return _pyglass.RasterTypeToDataTypeAndChannel(rd, d, c)

def GetDataTypeAsString(dataType: "ProjectIO::DataType") -> "std::string":
    return _pyglass.GetDataTypeAsString(dataType)
class Project(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def CreateMouselight() -> "ProjectIO::Project":
        return _pyglass.Project_CreateMouselight()

    @staticmethod
    def CreateImaris() -> "ProjectIO::Project":
        return _pyglass.Project_CreateImaris()

    @staticmethod
    def CreateTestProject() -> "ProjectIO::Project":
        return _pyglass.Project_CreateTestProject()

    def __init__(self, *args):
        _pyglass.Project_swiginit(self, _pyglass.new_Project(*args))

    def Init(self, dataType: "ProjectIO::DataType", channels: "ProjectIO::Channels", blockSize: "ivec3", FrameCount: "int", pyramidHeight: "int") -> "void":
        return _pyglass.Project_Init(self, dataType, channels, blockSize, FrameCount, pyramidHeight)

    def FinilizeConversion(self) -> "void":
        return _pyglass.Project_FinilizeConversion(self)

    def Close(self) -> "void":
        return _pyglass.Project_Close(self)

    def Wait(self) -> "void":
        return _pyglass.Project_Wait(self)

    def AddBlock(self, raster: "Raster", timepoint: "int", path: "int", mr: "MemoryReservation", cache: "bool") -> "bool":
        return _pyglass.Project_AddBlock(self, raster, timepoint, path, mr, cache)

    def GetBlock(self, timepoint: "int", path: "int", createRequestIfNo: "bool") -> "Raster":
        return _pyglass.Project_GetBlock(self, timepoint, path, createRequestIfNo)

    def DoesBlockExist(self, timepoint: "int", path: "int") -> "bool":
        return _pyglass.Project_DoesBlockExist(self, timepoint, path)

    def GetBlockSynchronous(self, timepoint: "int", path: "int", mr: "MemoryReservation", cache: "bool") -> "Raster":
        return _pyglass.Project_GetBlockSynchronous(self, timepoint, path, mr, cache)

    def GetStatus(self) -> "ProjectIO::ProjectStatus":
        return _pyglass.Project_GetStatus(self)

    def GetReserver(self) -> "MemoryReserver":
        return _pyglass.Project_GetReserver(self)

    def GetFrameCount(self) -> "int":
        return _pyglass.Project_GetFrameCount(self)

    def GetPyramidHeight(self) -> "int":
        return _pyglass.Project_GetPyramidHeight(self)

    def GetTreeK(self) -> "int":
        return _pyglass.Project_GetTreeK(self)

    def SetVoxelSize(self, voxelSize: "vec3") -> "void":
        return _pyglass.Project_SetVoxelSize(self, voxelSize)

    def GetVoxelSize(self) -> "glm::vec3":
        return _pyglass.Project_GetVoxelSize(self)

    def SetVoxelUnit(self, voxelUnit: "std::string const &") -> "void":
        return _pyglass.Project_SetVoxelUnit(self, voxelUnit)

    def GetVoxelUnit(self) -> "std::string":
        return _pyglass.Project_GetVoxelUnit(self)

    def SetProjectCreationTime(self) -> "void":
        return _pyglass.Project_SetProjectCreationTime(self)

    def GetProjectCreationTime(self) -> "std::string":
        return _pyglass.Project_GetProjectCreationTime(self)

    def GetBlockSize(self) -> "glm::ivec3":
        return _pyglass.Project_GetBlockSize(self)

    def GetProjectName(self) -> "std::string":
        return _pyglass.Project_GetProjectName(self)

    def GetChannelCount(self) -> "ProjectIO::Channels":
        return _pyglass.Project_GetChannelCount(self)

    def GetDataType(self) -> "ProjectIO::DataType":
        return _pyglass.Project_GetDataType(self)

    def GetPathToSygFile(self) -> "fs::path":
        return _pyglass.Project_GetPathToSygFile(self)

    def GetCacheSize(self) -> "size_t":
        return _pyglass.Project_GetCacheSize(self)

    def SetMinCacheSize(self, minCacheSize: "size_t") -> "void":
        return _pyglass.Project_SetMinCacheSize(self, minCacheSize)

    def SetMaxCacheSize(self, maxCacheSize: "size_t") -> "void":
        return _pyglass.Project_SetMaxCacheSize(self, maxCacheSize)

    def GetMaxCacheSize(self) -> "size_t":
        return _pyglass.Project_GetMaxCacheSize(self)

    def GetSWCTransform(self) -> "glm::mat4":
        return _pyglass.Project_GetSWCTransform(self)

    def GetDBAccessor(self) -> "ProjectIO::DBAccessor":
        return _pyglass.Project_GetDBAccessor(self)

    def GetProjectDimensions(self) -> "glm::vec3":
        return _pyglass.Project_GetProjectDimensions(self)

    def GetProjectDimensionsInUnitVoxels(self) -> "glm::ivec3":
        return _pyglass.Project_GetProjectDimensionsInUnitVoxels(self)

    def GetProjectHash(self) -> "std::string":
        return _pyglass.Project_GetProjectHash(self)

    def DeleteExperiment(self, name: "std::string const &") -> "void":
        return _pyglass.Project_DeleteExperiment(self, name)

    def AddExperiment(self, name: "std::string const &") -> "void":
        return _pyglass.Project_AddExperiment(self, name)

    def SetExperiment(self, name: "std::string const &") -> "void":
        return _pyglass.Project_SetExperiment(self, name)

    def GetCurrentExperiment(self) -> "std::string":
        return _pyglass.Project_GetCurrentExperiment(self)

    def CopyAnnotations(self, key: "std::string const &", sourceDir: "std::string const &", destinationDir: "std::string const &") -> "bool":
        return _pyglass.Project_CopyAnnotations(self, key, sourceDir, destinationDir)

    def CopyExperiment(self, sourceDir: "std::string const &", destinationDir: "std::string const &") -> "bool":
        return _pyglass.Project_CopyExperiment(self, sourceDir, destinationDir)

    def GetCutplanes(self, dir: "std::string const &") -> "std::vector< glm::vec4,std::allocator< glm::vec4 > >":
        return _pyglass.Project_GetCutplanes(self, dir)

    def ImportMeshOBJs(self, dir: "std::string const &", paths: "std::string const &") -> "bool":
        return _pyglass.Project_ImportMeshOBJs(self, dir, paths)

    def ImportMeshOBJsSync(self, dir: "std::string const &", paths: "PathList") -> "bool":
        return _pyglass.Project_ImportMeshOBJsSync(self, dir, paths)

    def ExportMeshOBJs(self, dir: "std::string const &", names: "std::string const &", paths: "std::string const &") -> "bool":
        return _pyglass.Project_ExportMeshOBJs(self, dir, names, paths)

    def CancelMeshIO(self) -> "void":
        return _pyglass.Project_CancelMeshIO(self)

    def GetMeshIOPercentage(self) -> "float":
        return _pyglass.Project_GetMeshIOPercentage(self)

    def GetMeshIOName(self) -> "std::string":
        return _pyglass.Project_GetMeshIOName(self)

    def GetMeshIOItemizedProgress(self) -> "std::pair< int,int >":
        return _pyglass.Project_GetMeshIOItemizedProgress(self)

    def ExportCountJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportCountJSON(self, dir, path)

    def ExportCountCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportCountCSV(self, dir, path)

    def ExportTraceJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportTraceJSON(self, dir, path)

    def ExportTraceCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportTraceCSV(self, dir, path)

    def ExportMeasurementJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportMeasurementJSON(self, dir, path)

    def ExportMeasurementCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportMeasurementCSV(self, dir, path)

    def ImportMeasurementJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportMeasurementJSON(self, dir, path)

    def ImportMeasurementCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportMeasurementCSV(self, dir, path)

    def ImportCountJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportCountJSON(self, dir, path)

    def ImportCountCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportCountCSV(self, dir, path)

    def ImportCountCSVFromVaa3D(self, dir: "std::string const &", path: "std::string const &", pixelCount: "vec3") -> "bool":
        return _pyglass.Project_ImportCountCSVFromVaa3D(self, dir, path, pixelCount)

    def ImportCountLists(self, allCountingPoints: "std::vector< std::vector< glm::vec3,std::allocator< glm::vec3 > >,std::allocator< std::vector< glm::vec3,std::allocator< glm::vec3 > > > > const &") -> "bool":
        return _pyglass.Project_ImportCountLists(self, allCountingPoints)

    def ImportTraceJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportTraceJSON(self, dir, path)

    def ImportTraceCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportTraceCSV(self, dir, path)

    def ExportSkeletonHOC(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportSkeletonHOC(self, dir, path)

    def ExportSkeletonSWC(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportSkeletonSWC(self, dir, path)

    def ExportSkeletonCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportSkeletonCSV(self, dir, path)

    def ExportAdjacencyListCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportAdjacencyListCSV(self, dir, path)

    def ImportSkeletonSWC(self, dir: "std::string const &", paths: "StringList") -> "bool":
        return _pyglass.Project_ImportSkeletonSWC(self, dir, paths)

    def ImportSkeletonSWCFromVaa3D(self, dir: "std::string const &", path: "std::string const &", pixelCount: "vec3") -> "bool":
        return _pyglass.Project_ImportSkeletonSWCFromVaa3D(self, dir, path, pixelCount)

    def ImportSkeletonHOC(self, dir: "std::string const &", paths: "StringList") -> "bool":
        return _pyglass.Project_ImportSkeletonHOC(self, dir, paths)

    def ImportSWCGraph(self, graph: "SWCP::Graph &") -> "bool":
        return _pyglass.Project_ImportSWCGraph(self, graph)

    def ExportMeshReviewJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportMeshReviewJSON(self, dir, path)

    def ImportMeshReviewJSON(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportMeshReviewJSON(self, dir, path)

    def ImportMultivariateDataCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportMultivariateDataCSV(self, dir, path)

    def GetNumberOfMVDPoints(self, dir: "std::string const &") -> "int":
        return _pyglass.Project_GetNumberOfMVDPoints(self, dir)

    def DeleteMultivariateData(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteMultivariateData(self, dir)

    def GetNumberOfOnionSeries(self, dir: "std::string const &") -> "int":
        return _pyglass.Project_GetNumberOfOnionSeries(self, dir)

    def DeleteOnionSeries(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteOnionSeries(self, dir)

    def ExportOnionSeriesCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ExportOnionSeriesCSV(self, dir, path)

    def ImportOnionSeriesCSV(self, dir: "std::string const &", path: "std::string const &") -> "bool":
        return _pyglass.Project_ImportOnionSeriesCSV(self, dir, path)

    def GetMeshNamesAndSizes(self, dir: "std::string const &") -> "std::map< std::string,std::pair< int,int >,std::less< std::string >,std::allocator< std::pair< std::string const,std::pair< int,int > > > >":
        return _pyglass.Project_GetMeshNamesAndSizes(self, dir)

    def DeleteMeshByName(self, dir: "std::string const &", name: "std::string const &") -> "void":
        return _pyglass.Project_DeleteMeshByName(self, dir, name)

    def RenameMesh(self, dir: "std::string const &", oldName: "std::string const &", newName: "std::string const &") -> "void":
        return _pyglass.Project_RenameMesh(self, dir, oldName, newName)

    def DeleteAllMeshes(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteAllMeshes(self, dir)

    def SetMeshColor(self, dir: "std::string const &", meshName: "std::string const &", color: "int const &") -> "bool":
        return _pyglass.Project_SetMeshColor(self, dir, meshName, color)

    def GetMeshColors(self, dir: "std::string const &") -> "std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > >":
        return _pyglass.Project_GetMeshColors(self, dir)

    def RandomizeMeshColors(self, dir: "std::string const &") -> "bool":
        return _pyglass.Project_RandomizeMeshColors(self, dir)

    def SetPDB(self, *args) -> "bool":
        return _pyglass.Project_SetPDB(self, *args)

    def GetPDBs(self, dir: "std::string const &") -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.Project_GetPDBs(self, dir)

    def DeletePDB(self, dir: "std::string const &", pdbName: "std::string const &") -> "bool":
        return _pyglass.Project_DeletePDB(self, dir, pdbName)

    def GetTags(self, dir: "std::string const &") -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.Project_GetTags(self, dir)

    def CreateTag(self, dir: "std::string const &", tagName: "std::string const &") -> "bool":
        return _pyglass.Project_CreateTag(self, dir, tagName)

    def DeleteTag(self, dir: "std::string const &", tagName: "std::string const &") -> "bool":
        return _pyglass.Project_DeleteTag(self, dir, tagName)

    def AddTagToMesh(self, dir: "std::string const &", tagName: "std::string const &", meshName: "std::string const &") -> "bool":
        return _pyglass.Project_AddTagToMesh(self, dir, tagName, meshName)

    def RemoveTagFromMesh(self, dir: "std::string const &", tagName: "std::string const &", meshName: "std::string const &") -> "bool":
        return _pyglass.Project_RemoveTagFromMesh(self, dir, tagName, meshName)

    def GetMeshTags(self, dir: "std::string const &", meshName: "std::string const &") -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.Project_GetMeshTags(self, dir, meshName)

    def SetTagOpacity(self, dir: "std::string const &", tag: "std::string const &", opacity: "float") -> "void":
        return _pyglass.Project_SetTagOpacity(self, dir, tag, opacity)

    def SetDVIDFields(self, dir: "std::string const &", dvidServer: "std::string const &", dvidUUID: "std::string const &", dvidDataTypeName: "std::string const &") -> "bool":
        return _pyglass.Project_SetDVIDFields(self, dir, dvidServer, dvidUUID, dvidDataTypeName)

    def GetDVIDServer(self, dir: "std::string const &") -> "std::string":
        return _pyglass.Project_GetDVIDServer(self, dir)

    def GetDVIDUUID(self, dir: "std::string const &") -> "std::string":
        return _pyglass.Project_GetDVIDUUID(self, dir)

    def GetDVIDDataTypeName(self, dir: "std::string const &") -> "std::string":
        return _pyglass.Project_GetDVIDDataTypeName(self, dir)

    def GetNumberOfSkeletonNodes(self, dir: "std::string const &") -> "int":
        return _pyglass.Project_GetNumberOfSkeletonNodes(self, dir)

    def DeleteSkeletons(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteSkeletons(self, dir)

    def GetNumberOfMeasurements(self, dir: "std::string const &") -> "int":
        return _pyglass.Project_GetNumberOfMeasurements(self, dir)

    def DeleteMeasurements(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteMeasurements(self, dir)

    def GetNumberOfTraces(self, dir: "std::string const &") -> "int":
        return _pyglass.Project_GetNumberOfTraces(self, dir)

    def DeleteTraces(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteTraces(self, dir)

    def GetNumberOfCounts(self, dir: "std::string const &") -> "int":
        return _pyglass.Project_GetNumberOfCounts(self, dir)

    def DeleteCounts(self, dir: "std::string const &") -> "void":
        return _pyglass.Project_DeleteCounts(self, dir)

    def SetCitation(self, citationText: "std::string const &") -> "void":
        return _pyglass.Project_SetCitation(self, citationText)

    def GetCitation(self) -> "std::string":
        return _pyglass.Project_GetCitation(self)

    def CreateLabel(self, dir: "std::string const &", label: "std::string const &") -> "bool":
        return _pyglass.Project_CreateLabel(self, dir, label)

    def DeleteLabel(self, dir: "std::string const &", label: "std::string const &") -> "bool":
        return _pyglass.Project_DeleteLabel(self, dir, label)

    def GetLabels(self, dir: "std::string const &") -> "std::vector< std::string,std::allocator< std::string > >":
        return _pyglass.Project_GetLabels(self, dir)

    def CopyShaderSettingsFromProject(self, source: "Project") -> "void":
        return _pyglass.Project_CopyShaderSettingsFromProject(self, source)

    def SetCoordinateFrame(self, coordinateFrame: "ProjectIO::CoordinateFrame const &") -> "void":
        return _pyglass.Project_SetCoordinateFrame(self, coordinateFrame)

    def GetMaskRaster(self, dir: "std::string const &", roiDims: "ivec3", roiIndex: "int") -> "Raster":
        return _pyglass.Project_GetMaskRaster(self, dir, roiDims, roiIndex)

    def SetMaskRaster(self, maskRaster: "Raster", roiIndex: "int", dir: "std::string const &") -> "bool":
        return _pyglass.Project_SetMaskRaster(self, maskRaster, roiIndex, dir)

    def GetMinROIPoint(self, dir: "std::string const &", roiIndex: "int"=1) -> "glm::vec3":
        return _pyglass.Project_GetMinROIPoint(self, dir, roiIndex)

    def GetMaxROIPoint(self, dir: "std::string const &", roiIndex: "int"=1) -> "glm::vec3":
        return _pyglass.Project_GetMaxROIPoint(self, dir, roiIndex)

    def GetRoiIDList(self) -> "std::vector< int,std::allocator< int > >":
        return _pyglass.Project_GetRoiIDList(self)

    def SetSampleWeight(self, sampleWeight: "float") -> "void":
        return _pyglass.Project_SetSampleWeight(self, sampleWeight)

    def GetSampleWeight(self) -> "float":
        return _pyglass.Project_GetSampleWeight(self)

    def GetTotalGrayLevelEstimate(self, channel: "int") -> "size_t":
        return _pyglass.Project_GetTotalGrayLevelEstimate(self, channel)

    def SetAcquisitionCoordinate(self, coordinate: "vec3") -> "void":
        return _pyglass.Project_SetAcquisitionCoordinate(self, coordinate)

    def GetAcquisitionCoordinate(self) -> "glm::vec3":
        return _pyglass.Project_GetAcquisitionCoordinate(self)

    def SetLiveAcquisitionDirectory(self, liveDirectory: "std::string const &") -> "void":
        return _pyglass.Project_SetLiveAcquisitionDirectory(self, liveDirectory)

    def GetLiveAcquisitionDirectory(self) -> "std::string":
        return _pyglass.Project_GetLiveAcquisitionDirectory(self)

    def SetLiveFilesPerImage(self, liveFilesPerImage: "int") -> "void":
        return _pyglass.Project_SetLiveFilesPerImage(self, liveFilesPerImage)

    def GetLiveFilesPerImage(self) -> "int":
        return _pyglass.Project_GetLiveFilesPerImage(self)

    def GetBlockHash(self) -> "std::string":
        return _pyglass.Project_GetBlockHash(self)

    def CreateBlockHash(self) -> "void":
        return _pyglass.Project_CreateBlockHash(self)
    __swig_destroy__ = _pyglass.delete_Project

# Register Project in _pyglass:
_pyglass.Project_swigregister(Project)

def Project_CreateMouselight() -> "ProjectIO::Project":
    return _pyglass.Project_CreateMouselight()

def Project_CreateImaris() -> "ProjectIO::Project":
    return _pyglass.Project_CreateImaris()

def Project_CreateTestProject() -> "ProjectIO::Project":
    return _pyglass.Project_CreateTestProject()

class Raster(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    R8 = _pyglass.Raster_R8
    R16 = _pyglass.Raster_R16
    R32 = _pyglass.Raster_R32
    RG8 = _pyglass.Raster_RG8
    RG16 = _pyglass.Raster_RG16
    RG32 = _pyglass.Raster_RG32
    RGB8 = _pyglass.Raster_RGB8
    RGB16 = _pyglass.Raster_RGB16
    RGB32 = _pyglass.Raster_RGB32
    RGBA8 = _pyglass.Raster_RGBA8
    RGBA16 = _pyglass.Raster_RGBA16
    RGBA32 = _pyglass.Raster_RGBA32
    RF = _pyglass.Raster_RF
    RGF = _pyglass.Raster_RGF
    RGBF = _pyglass.Raster_RGBF
    RGBAF = _pyglass.Raster_RGBAF
    RHF = _pyglass.Raster_RHF
    RGHF = _pyglass.Raster_RGHF
    RGBHF = _pyglass.Raster_RGBHF
    RGBAHF = _pyglass.Raster_RGBAHF

    @staticmethod
    def GetBytesPerVoxel(*args) -> "size_t":
        return _pyglass.Raster_GetBytesPerVoxel(*args)

    def Valid(self) -> "bool":
        return _pyglass.Raster_Valid(self)

    def GetSize(self) -> "glm::ivec3":
        return _pyglass.Raster_GetSize(self)

    def GetDataSize(self) -> "size_t":
        return _pyglass.Raster_GetDataSize(self)

    def GetScanLineSizeAligned(self) -> "size_t":
        return _pyglass.Raster_GetScanLineSizeAligned(self)

    def GetScanLineSize(self) -> "size_t":
        return _pyglass.Raster_GetScanLineSize(self)

    def SetDataType(self, type: "Raster::DataType") -> "void":
        return _pyglass.Raster_SetDataType(self, type)

    def GetDataType(self) -> "Raster::DataType":
        return _pyglass.Raster_GetDataType(self)

    @staticmethod
    def ConstructEmpty(*args) -> "Raster":
        return _pyglass.Raster_ConstructEmpty(*args)

    @staticmethod
    def ConstructFromData(d: "Raster::DataType", size: "ivec3", m_ptr: "std::shared_ptr< uint8_t >") -> "Raster":
        return _pyglass.Raster_ConstructFromData(d, size, m_ptr)

    @staticmethod
    def ConstructEmptyFileMapped(d: "Raster::DataType", size: "ivec3", file: "std::string const &") -> "Raster":
        return _pyglass.Raster_ConstructEmptyFileMapped(d, size, file)

    def GetScanLinePtr(self, *args) -> "uint8_t const *":
        return _pyglass.Raster_GetScanLinePtr(self, *args)

    def Place(self, r: "Raster", pos: "ivec3") -> "void":
        return _pyglass.Raster_Place(self, r, pos)

    def PlaceResized(self, r: "Raster", pos: "ivec3", size: "ivec3") -> "void":
        return _pyglass.Raster_PlaceResized(self, r, pos, size)

    def Crop(self, pos: "ivec3", size: "ivec3") -> "Raster":
        return _pyglass.Raster_Crop(self, pos, size)

    def DownSample2X(self, *args) -> "Raster":
        return _pyglass.Raster_DownSample2X(self, *args)

    @staticmethod
    def GetMask(i: "int") -> "glm::ivec3":
        return _pyglass.Raster_GetMask(i)

    @staticmethod
    def Combine(*args) -> "Raster":
        return _pyglass.Raster_Combine(*args)

    def ExtractChannel(self, channel: "int") -> "Raster":
        return _pyglass.Raster_ExtractChannel(self, channel)

    def Inverse(self) -> "Raster":
        return _pyglass.Raster_Inverse(self)

    def ConvertTo8Bit(self) -> "Raster":
        return _pyglass.Raster_ConvertTo8Bit(self)

    def ConvertTo16Bit(self) -> "Raster":
        return _pyglass.Raster_ConvertTo16Bit(self)

    def ConvertToFloat(self) -> "Raster":
        return _pyglass.Raster_ConvertToFloat(self)

    def ConvertToR16Bit(self, channel: "int") -> "Raster":
        return _pyglass.Raster_ConvertToR16Bit(self, channel)

    def Resize(self, size: "ivec3", aligned: "bool"=True) -> "Raster":
        return _pyglass.Raster_Resize(self, size, aligned)

    def LinearTransform(self, a: "float", b: "float") -> "Raster":
        return _pyglass.Raster_LinearTransform(self, a, b)

    def MirrorY(self) -> "Raster":
        return _pyglass.Raster_MirrorY(self)

    def Clear(self, pos: "ivec3", size: "ivec3") -> "void":
        return _pyglass.Raster_Clear(self, pos, size)

    def Export(self, path: "std::string") -> "void":
        return _pyglass.Raster_Export(self, path)

    def Import(self, path: "std::string") -> "void":
        return _pyglass.Raster_Import(self, path)

    def AssignMemoryReservation(self, mr: "MemoryReservation") -> "void":
        return _pyglass.Raster_AssignMemoryReservation(self, mr)

    def size(self) -> "size_t":
        return _pyglass.Raster_size(self)

    def __init__(self):
        _pyglass.Raster_swiginit(self, _pyglass.new_Raster())
    __swig_destroy__ = _pyglass.delete_Raster

# Register Raster in _pyglass:
_pyglass.Raster_swigregister(Raster)

def Raster_GetBytesPerVoxel(*args) -> "size_t":
    return _pyglass.Raster_GetBytesPerVoxel(*args)

def Raster_ConstructEmpty(*args) -> "Raster":
    return _pyglass.Raster_ConstructEmpty(*args)

def Raster_ConstructFromData(d: "Raster::DataType", size: "ivec3", m_ptr: "std::shared_ptr< uint8_t >") -> "Raster":
    return _pyglass.Raster_ConstructFromData(d, size, m_ptr)

def Raster_ConstructEmptyFileMapped(d: "Raster::DataType", size: "ivec3", file: "std::string const &") -> "Raster":
    return _pyglass.Raster_ConstructEmptyFileMapped(d, size, file)

def Raster_GetMask(i: "int") -> "glm::ivec3":
    return _pyglass.Raster_GetMask(i)

def Raster_Combine(*args) -> "Raster":
    return _pyglass.Raster_Combine(*args)


def GetRasterAsNumpyArray(r: "Raster", channelShape: "bool"=True) -> "PyObject *":
    return _pyglass.GetRasterAsNumpyArray(r, channelShape)

def GetRasterFromNumpyArray(pyArray: "PyObject *") -> "Raster":
    return _pyglass.GetRasterFromNumpyArray(pyArray)

def SLIC(r: "Raster", mask: "Raster", voxelSize: "vec3", compactness: "float", numberOfSegments: "int") -> "Raster":
    return _pyglass.SLIC(r, mask, voxelSize, compactness, numberOfSegments)

def RunPythonScript(path: "std::string const &", selectedPaths: "StringList") -> "std::string":
    return _pyglass.RunPythonScript(path, selectedPaths)

def InitSkimage() -> "void":
    return _pyglass.InitSkimage()
class IFile(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyglass.delete_IFile
    FILE_READ = _pyglass.IFile_FILE_READ
    FILE_WRITE = _pyglass.IFile_FILE_WRITE
    FILE_APPEND = _pyglass.IFile_FILE_APPEND
    FILE_APPEND_PLUS = _pyglass.IFile_FILE_APPEND_PLUS
    FILE_READ_UPDATE = _pyglass.IFile_FILE_READ_UPDATE
    FILE_WRITE_UPDATE = _pyglass.IFile_FILE_WRITE_UPDATE
    FILE_APPEND_UPDATE = _pyglass.IFile_FILE_APPEND_UPDATE

    def GetPointerConst(self) -> "char const *":
        return _pyglass.IFile_GetPointerConst(self)

    def GetPointer(self) -> "char *":
        return _pyglass.IFile_GetPointer(self)

    def Open(self, filename: "path", mode: "SB::IFile::MODE") -> "bool":
        return _pyglass.IFile_Open(self, filename, mode)

    def Valid(self) -> "bool":
        return _pyglass.IFile_Valid(self)

    def Seek(self, position: "size_t") -> "void":
        return _pyglass.IFile_Seek(self, position)

    def Tell(self) -> "size_t":
        return _pyglass.IFile_Tell(self)

    def GetSize(self) -> "size_t":
        return _pyglass.IFile_GetSize(self)

    def Read(self, destanation: "char *", size: "size_t", readSize: "size_t *"=None) -> "bool":
        return _pyglass.IFile_Read(self, destanation, size, readSize)

    def Write(self, *args) -> "bool":
        return _pyglass.IFile_Write(self, *args)

    def Flush(self) -> "void":
        return _pyglass.IFile_Flush(self)

# Register IFile in _pyglass:
_pyglass.IFile_swigregister(IFile)

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

    def __init__(self, *args):
        _pyglass.FileHandle_swiginit(self, _pyglass.new_FileHandle(*args))

    def GetPath(self) -> "boost::filesystem::path const &":
        return _pyglass.FileHandle_GetPath(self)

    def GetPointerConst(self) -> "char const *":
        return _pyglass.FileHandle_GetPointerConst(self)

    def GetPointer(self) -> "char *":
        return _pyglass.FileHandle_GetPointer(self)

    def Open(self, filename: "path", mode: "SB::IFile::MODE") -> "bool":
        return _pyglass.FileHandle_Open(self, filename, mode)

    def Valid(self) -> "bool":
        return _pyglass.FileHandle_Valid(self)

    def Seek(self, position: "size_t") -> "void":
        return _pyglass.FileHandle_Seek(self, position)

    def Tell(self) -> "size_t":
        return _pyglass.FileHandle_Tell(self)

    def GetSize(self) -> "size_t":
        return _pyglass.FileHandle_GetSize(self)

    def Read(self, destanation: "char *", size: "size_t", readSize: "size_t *"=None) -> "bool":
        return _pyglass.FileHandle_Read(self, destanation, size, readSize)

    def Write(self, *args) -> "bool":
        return _pyglass.FileHandle_Write(self, *args)

    def ReadCompressed(self, destanation: "char *", size: "size_t", readSize: "size_t *"=None) -> "bool":
        return _pyglass.FileHandle_ReadCompressed(self, destanation, size, readSize)

    def WriteCompressed(self, source: "char const *", size: "size_t") -> "bool":
        return _pyglass.FileHandle_WriteCompressed(self, source, size)

    def ReadByte(self, byte: "int8_t &") -> "bool":
        return _pyglass.FileHandle_ReadByte(self, byte)

    def ReadInt(self, integer: "int32_t &") -> "bool":
        return _pyglass.FileHandle_ReadInt(self, integer)

    def ReadUInt(self, integer: "uint32_t &") -> "bool":
        return _pyglass.FileHandle_ReadUInt(self, integer)

    def ReadInt64(self, integer: "int64_t &") -> "bool":
        return _pyglass.FileHandle_ReadInt64(self, integer)

    def ReadUInt64(self, integer: "uint64_t &") -> "bool":
        return _pyglass.FileHandle_ReadUInt64(self, integer)

    def ReadInt16(self, integer: "int16_t &") -> "bool":
        return _pyglass.FileHandle_ReadInt16(self, integer)

    def ReadUInt16(self, integer: "uint16_t &") -> "bool":
        return _pyglass.FileHandle_ReadUInt16(self, integer)

    def ReadFloat(self, floatValue: "float &") -> "bool":
        return _pyglass.FileHandle_ReadFloat(self, floatValue)

    def ReadDouble(self, doubleValue: "double &") -> "bool":
        return _pyglass.FileHandle_ReadDouble(self, doubleValue)

    def ReadBool(self, boolValue: "bool &") -> "bool":
        return _pyglass.FileHandle_ReadBool(self, boolValue)

    def ReadString(self, str: "std::string &") -> "bool":
        return _pyglass.FileHandle_ReadString(self, str)

    def WriteByte(self, byte: "int8_t") -> "bool":
        return _pyglass.FileHandle_WriteByte(self, byte)

    def WriteInt(self, integer: "int32_t") -> "bool":
        return _pyglass.FileHandle_WriteInt(self, integer)

    def WriteUInt(self, integer: "uint32_t") -> "bool":
        return _pyglass.FileHandle_WriteUInt(self, integer)

    def WriteInt64(self, integer: "int64_t") -> "bool":
        return _pyglass.FileHandle_WriteInt64(self, integer)

    def WriteUInt64(self, integer: "uint64_t") -> "bool":
        return _pyglass.FileHandle_WriteUInt64(self, integer)

    def WriteInt16(self, integer: "int16_t") -> "bool":
        return _pyglass.FileHandle_WriteInt16(self, integer)

    def WriteUInt16(self, integer: "uint16_t") -> "bool":
        return _pyglass.FileHandle_WriteUInt16(self, integer)

    def WriteFloat(self, floatValue: "float") -> "bool":
        return _pyglass.FileHandle_WriteFloat(self, floatValue)

    def WriteDouble(self, doubleValue: "double") -> "bool":
        return _pyglass.FileHandle_WriteDouble(self, doubleValue)

    def WriteBool(self, boolValue: "bool") -> "bool":
        return _pyglass.FileHandle_WriteBool(self, boolValue)

    def WriteString(self, str: "std::string const &") -> "bool":
        return _pyglass.FileHandle_WriteString(self, str)

    def Flush(self) -> "void":
        return _pyglass.FileHandle_Flush(self)
    __swig_destroy__ = _pyglass.delete_FileHandle

# Register FileHandle in _pyglass:
_pyglass.FileHandle_swigregister(FileHandle)

class Location(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Resources = _pyglass.Location_Resources
    RoamingAppData = _pyglass.Location_RoamingAppData
    LocalAppData = _pyglass.Location_LocalAppData
    UserPictures = _pyglass.Location_UserPictures
    UserVideos = _pyglass.Location_UserVideos
    ProgramData = _pyglass.Location_ProgramData
    ProgramFiles = _pyglass.Location_ProgramFiles
    Documents = _pyglass.Location_Documents
    Temp = _pyglass.Location_Temp
    WorkingDir = _pyglass.Location_WorkingDir
    UserMusic = _pyglass.Location_UserMusic

    def __init__(self):
        _pyglass.Location_swiginit(self, _pyglass.new_Location())
    __swig_destroy__ = _pyglass.delete_Location

# Register Location in _pyglass:
_pyglass.Location_swigregister(Location)

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

    @staticmethod
    def OpenFile(*args) -> "SB::FileHandle":
        return _pyglass.FileSystem_OpenFile(*args)

    @staticmethod
    def OpenFileAuto(*args) -> "SB::FileHandle":
        return _pyglass.FileSystem_OpenFileAuto(*args)

    @staticmethod
    def Copy(*args) -> "void":
        return _pyglass.FileSystem_Copy(*args)

    @staticmethod
    def IsDirectory(*args) -> "bool":
        return _pyglass.FileSystem_IsDirectory(*args)

    @staticmethod
    def IsFile(*args) -> "bool":
        return _pyglass.FileSystem_IsFile(*args)

    @staticmethod
    def IsLocal(*args) -> "bool":
        return _pyglass.FileSystem_IsLocal(*args)

    @staticmethod
    def GetAbsolutePath(path: "path", location: "SB::Location::Type") -> "boost::filesystem::path":
        return _pyglass.FileSystem_GetAbsolutePath(path, location)

    @staticmethod
    def GetNativePathString(path: "path") -> "std::string":
        return _pyglass.FileSystem_GetNativePathString(path)

    @staticmethod
    def GetNativeParentPathString(path: "path") -> "std::string":
        return _pyglass.FileSystem_GetNativeParentPathString(path)

    @staticmethod
    def Rename(source: "path", destination: "path", location: "SB::Location::Type") -> "int":
        return _pyglass.FileSystem_Rename(source, destination, location)

    @staticmethod
    def Delete(path: "path", location: "SB::Location::Type") -> "void":
        return _pyglass.FileSystem_Delete(path, location)

    @staticmethod
    def AddResourcesSearchPath(path: "path") -> "void":
        return _pyglass.FileSystem_AddResourcesSearchPath(path)

    @staticmethod
    def AddArchive(archive: "SB::ZipReaderPtr") -> "void":
        return _pyglass.FileSystem_AddArchive(archive)

    @staticmethod
    def GetFileList(filemask: "std::string const &", resultList: "StringList", sortByCreationTime: "bool"=False) -> "bool const":
        return _pyglass.FileSystem_GetFileList(filemask, resultList, sortByCreationTime)

    @staticmethod
    def MkDir(path: "path") -> "int":
        return _pyglass.FileSystem_MkDir(path)

    @staticmethod
    def GetTimes(path: "path", atime: "time_t &", mtime: "time_t &", ctime: "time_t &") -> "void":
        return _pyglass.FileSystem_GetTimes(path, atime, mtime, ctime)

    @staticmethod
    def GetInstallationPath() -> "boost::filesystem::path":
        return _pyglass.FileSystem_GetInstallationPath()

    @staticmethod
    def DumpSystemPaths() -> "void":
        return _pyglass.FileSystem_DumpSystemPaths()

    @staticmethod
    def GenDateTimeSecStr() -> "std::string":
        return _pyglass.FileSystem_GenDateTimeSecStr()

    @staticmethod
    def GrantAllUsersFilePermission(path: "path") -> "void":
        return _pyglass.FileSystem_GrantAllUsersFilePermission(path)

    @staticmethod
    def GetPathFromBytes(bytes: "uint8_t *") -> "boost::filesystem::path":
        return _pyglass.FileSystem_GetPathFromBytes(bytes)

    def __init__(self):
        _pyglass.FileSystem_swiginit(self, _pyglass.new_FileSystem())
    __swig_destroy__ = _pyglass.delete_FileSystem

# Register FileSystem in _pyglass:
_pyglass.FileSystem_swigregister(FileSystem)

def FileSystem_OpenFile(*args) -> "SB::FileHandle":
    return _pyglass.FileSystem_OpenFile(*args)

def FileSystem_OpenFileAuto(*args) -> "SB::FileHandle":
    return _pyglass.FileSystem_OpenFileAuto(*args)

def FileSystem_Copy(*args) -> "void":
    return _pyglass.FileSystem_Copy(*args)

def FileSystem_IsDirectory(*args) -> "bool":
    return _pyglass.FileSystem_IsDirectory(*args)

def FileSystem_IsFile(*args) -> "bool":
    return _pyglass.FileSystem_IsFile(*args)

def FileSystem_IsLocal(*args) -> "bool":
    return _pyglass.FileSystem_IsLocal(*args)

def FileSystem_GetAbsolutePath(path: "path", location: "SB::Location::Type") -> "boost::filesystem::path":
    return _pyglass.FileSystem_GetAbsolutePath(path, location)

def FileSystem_GetNativePathString(path: "path") -> "std::string":
    return _pyglass.FileSystem_GetNativePathString(path)

def FileSystem_GetNativeParentPathString(path: "path") -> "std::string":
    return _pyglass.FileSystem_GetNativeParentPathString(path)

def FileSystem_Rename(source: "path", destination: "path", location: "SB::Location::Type") -> "int":
    return _pyglass.FileSystem_Rename(source, destination, location)

def FileSystem_Delete(path: "path", location: "SB::Location::Type") -> "void":
    return _pyglass.FileSystem_Delete(path, location)

def FileSystem_AddResourcesSearchPath(path: "path") -> "void":
    return _pyglass.FileSystem_AddResourcesSearchPath(path)

def FileSystem_AddArchive(archive: "SB::ZipReaderPtr") -> "void":
    return _pyglass.FileSystem_AddArchive(archive)

def FileSystem_GetFileList(filemask: "std::string const &", resultList: "StringList", sortByCreationTime: "bool"=False) -> "bool const":
    return _pyglass.FileSystem_GetFileList(filemask, resultList, sortByCreationTime)

def FileSystem_MkDir(path: "path") -> "int":
    return _pyglass.FileSystem_MkDir(path)

def FileSystem_GetTimes(path: "path", atime: "time_t &", mtime: "time_t &", ctime: "time_t &") -> "void":
    return _pyglass.FileSystem_GetTimes(path, atime, mtime, ctime)

def FileSystem_GetInstallationPath() -> "boost::filesystem::path":
    return _pyglass.FileSystem_GetInstallationPath()

def FileSystem_DumpSystemPaths() -> "void":
    return _pyglass.FileSystem_DumpSystemPaths()

def FileSystem_GenDateTimeSecStr() -> "std::string":
    return _pyglass.FileSystem_GenDateTimeSecStr()

def FileSystem_GrantAllUsersFilePermission(path: "path") -> "void":
    return _pyglass.FileSystem_GrantAllUsersFilePermission(path)

def FileSystem_GetPathFromBytes(bytes: "uint8_t *") -> "boost::filesystem::path":
    return _pyglass.FileSystem_GetPathFromBytes(bytes)


def BoostInit() -> "void":
    return _pyglass.BoostInit()
SHARED_PTR_DISOWN = _pyglass.SHARED_PTR_DISOWN
class VolumeLibraryList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.VolumeLibraryList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.VolumeLibraryList___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.VolumeLibraryList___bool__(self)

    def __len__(self) -> "std::vector< VolumeLibrary::LibraryEntry >::size_type":
        return _pyglass.VolumeLibraryList___len__(self)

    def __getslice__(self, i: "std::vector< VolumeLibrary::LibraryEntry >::difference_type", j: "std::vector< VolumeLibrary::LibraryEntry >::difference_type") -> "std::vector< VolumeLibrary::LibraryEntry,std::allocator< VolumeLibrary::LibraryEntry > > *":
        return _pyglass.VolumeLibraryList___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _pyglass.VolumeLibraryList___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< VolumeLibrary::LibraryEntry >::difference_type", j: "std::vector< VolumeLibrary::LibraryEntry >::difference_type") -> "void":
        return _pyglass.VolumeLibraryList___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _pyglass.VolumeLibraryList___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< VolumeLibrary::LibraryEntry >::value_type const &":
        return _pyglass.VolumeLibraryList___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _pyglass.VolumeLibraryList___setitem__(self, *args)

    def pop(self) -> "std::vector< VolumeLibrary::LibraryEntry >::value_type":
        return _pyglass.VolumeLibraryList_pop(self)

    def append(self, x: "LibraryEntry") -> "void":
        return _pyglass.VolumeLibraryList_append(self, x)

    def empty(self) -> "bool":
        return _pyglass.VolumeLibraryList_empty(self)

    def size(self) -> "std::vector< VolumeLibrary::LibraryEntry >::size_type":
        return _pyglass.VolumeLibraryList_size(self)

    def swap(self, v: "VolumeLibraryList") -> "void":
        return _pyglass.VolumeLibraryList_swap(self, v)

    def begin(self) -> "std::vector< VolumeLibrary::LibraryEntry >::iterator":
        return _pyglass.VolumeLibraryList_begin(self)

    def end(self) -> "std::vector< VolumeLibrary::LibraryEntry >::iterator":
        return _pyglass.VolumeLibraryList_end(self)

    def rbegin(self) -> "std::vector< VolumeLibrary::LibraryEntry >::reverse_iterator":
        return _pyglass.VolumeLibraryList_rbegin(self)

    def rend(self) -> "std::vector< VolumeLibrary::LibraryEntry >::reverse_iterator":
        return _pyglass.VolumeLibraryList_rend(self)

    def clear(self) -> "void":
        return _pyglass.VolumeLibraryList_clear(self)

    def get_allocator(self) -> "std::vector< VolumeLibrary::LibraryEntry >::allocator_type":
        return _pyglass.VolumeLibraryList_get_allocator(self)

    def pop_back(self) -> "void":
        return _pyglass.VolumeLibraryList_pop_back(self)

    def erase(self, *args) -> "std::vector< VolumeLibrary::LibraryEntry >::iterator":
        return _pyglass.VolumeLibraryList_erase(self, *args)

    def __init__(self, *args):
        _pyglass.VolumeLibraryList_swiginit(self, _pyglass.new_VolumeLibraryList(*args))

    def push_back(self, x: "LibraryEntry") -> "void":
        return _pyglass.VolumeLibraryList_push_back(self, x)

    def front(self) -> "std::vector< VolumeLibrary::LibraryEntry >::value_type const &":
        return _pyglass.VolumeLibraryList_front(self)

    def back(self) -> "std::vector< VolumeLibrary::LibraryEntry >::value_type const &":
        return _pyglass.VolumeLibraryList_back(self)

    def assign(self, n: "std::vector< VolumeLibrary::LibraryEntry >::size_type", x: "LibraryEntry") -> "void":
        return _pyglass.VolumeLibraryList_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _pyglass.VolumeLibraryList_resize(self, *args)

    def insert(self, *args) -> "void":
        return _pyglass.VolumeLibraryList_insert(self, *args)

    def reserve(self, n: "std::vector< VolumeLibrary::LibraryEntry >::size_type") -> "void":
        return _pyglass.VolumeLibraryList_reserve(self, n)

    def capacity(self) -> "std::vector< VolumeLibrary::LibraryEntry >::size_type":
        return _pyglass.VolumeLibraryList_capacity(self)
    __swig_destroy__ = _pyglass.delete_VolumeLibraryList

# Register VolumeLibraryList in _pyglass:
_pyglass.VolumeLibraryList_swigregister(VolumeLibraryList)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.Vec4List_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.Vec4List___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.Vec4List___bool__(self)

    def __len__(self) -> "std::vector< glm::tvec4< float,glm::highp > >::size_type":
        return _pyglass.Vec4List___len__(self)

    def __getslice__(self, i: "std::vector< glm::tvec4< float,glm::highp > >::difference_type", j: "std::vector< glm::tvec4< float,glm::highp > >::difference_type") -> "std::vector< glm::tvec4< float,glm::highp >,std::allocator< glm::tvec4< float,glm::highp > > > *":
        return _pyglass.Vec4List___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _pyglass.Vec4List___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< glm::tvec4< float,glm::highp > >::difference_type", j: "std::vector< glm::tvec4< float,glm::highp > >::difference_type") -> "void":
        return _pyglass.Vec4List___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _pyglass.Vec4List___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< glm::tvec4< float,glm::highp > >::value_type const &":
        return _pyglass.Vec4List___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _pyglass.Vec4List___setitem__(self, *args)

    def pop(self) -> "std::vector< glm::tvec4< float,glm::highp > >::value_type":
        return _pyglass.Vec4List_pop(self)

    def append(self, x: "vec4") -> "void":
        return _pyglass.Vec4List_append(self, x)

    def empty(self) -> "bool":
        return _pyglass.Vec4List_empty(self)

    def size(self) -> "std::vector< glm::tvec4< float,glm::highp > >::size_type":
        return _pyglass.Vec4List_size(self)

    def swap(self, v: "Vec4List") -> "void":
        return _pyglass.Vec4List_swap(self, v)

    def begin(self) -> "std::vector< glm::tvec4< float,glm::highp > >::iterator":
        return _pyglass.Vec4List_begin(self)

    def end(self) -> "std::vector< glm::tvec4< float,glm::highp > >::iterator":
        return _pyglass.Vec4List_end(self)

    def rbegin(self) -> "std::vector< glm::tvec4< float,glm::highp > >::reverse_iterator":
        return _pyglass.Vec4List_rbegin(self)

    def rend(self) -> "std::vector< glm::tvec4< float,glm::highp > >::reverse_iterator":
        return _pyglass.Vec4List_rend(self)

    def clear(self) -> "void":
        return _pyglass.Vec4List_clear(self)

    def get_allocator(self) -> "std::vector< glm::tvec4< float,glm::highp > >::allocator_type":
        return _pyglass.Vec4List_get_allocator(self)

    def pop_back(self) -> "void":
        return _pyglass.Vec4List_pop_back(self)

    def erase(self, *args) -> "std::vector< glm::tvec4< float,glm::highp > >::iterator":
        return _pyglass.Vec4List_erase(self, *args)

    def __init__(self, *args):
        _pyglass.Vec4List_swiginit(self, _pyglass.new_Vec4List(*args))

    def push_back(self, x: "vec4") -> "void":
        return _pyglass.Vec4List_push_back(self, x)

    def front(self) -> "std::vector< glm::tvec4< float,glm::highp > >::value_type const &":
        return _pyglass.Vec4List_front(self)

    def back(self) -> "std::vector< glm::tvec4< float,glm::highp > >::value_type const &":
        return _pyglass.Vec4List_back(self)

    def assign(self, n: "std::vector< glm::tvec4< float,glm::highp > >::size_type", x: "vec4") -> "void":
        return _pyglass.Vec4List_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _pyglass.Vec4List_resize(self, *args)

    def insert(self, *args) -> "void":
        return _pyglass.Vec4List_insert(self, *args)

    def reserve(self, n: "std::vector< glm::tvec4< float,glm::highp > >::size_type") -> "void":
        return _pyglass.Vec4List_reserve(self, n)

    def capacity(self) -> "std::vector< glm::tvec4< float,glm::highp > >::size_type":
        return _pyglass.Vec4List_capacity(self)
    __swig_destroy__ = _pyglass.delete_Vec4List

# Register Vec4List in _pyglass:
_pyglass.Vec4List_swigregister(Vec4List)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.ByteList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.ByteList___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.ByteList___bool__(self)

    def __len__(self) -> "std::vector< unsigned char >::size_type":
        return _pyglass.ByteList___len__(self)

    def __getslice__(self, i: "std::vector< unsigned char >::difference_type", j: "std::vector< unsigned char >::difference_type") -> "std::vector< unsigned char,std::allocator< unsigned char > > *":
        return _pyglass.ByteList___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _pyglass.ByteList___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< unsigned char >::difference_type", j: "std::vector< unsigned char >::difference_type") -> "void":
        return _pyglass.ByteList___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _pyglass.ByteList___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< unsigned char >::value_type const &":
        return _pyglass.ByteList___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _pyglass.ByteList___setitem__(self, *args)

    def pop(self) -> "std::vector< unsigned char >::value_type":
        return _pyglass.ByteList_pop(self)

    def append(self, x: "std::vector< unsigned char >::value_type const &") -> "void":
        return _pyglass.ByteList_append(self, x)

    def empty(self) -> "bool":
        return _pyglass.ByteList_empty(self)

    def size(self) -> "std::vector< unsigned char >::size_type":
        return _pyglass.ByteList_size(self)

    def swap(self, v: "ByteList") -> "void":
        return _pyglass.ByteList_swap(self, v)

    def begin(self) -> "std::vector< unsigned char >::iterator":
        return _pyglass.ByteList_begin(self)

    def end(self) -> "std::vector< unsigned char >::iterator":
        return _pyglass.ByteList_end(self)

    def rbegin(self) -> "std::vector< unsigned char >::reverse_iterator":
        return _pyglass.ByteList_rbegin(self)

    def rend(self) -> "std::vector< unsigned char >::reverse_iterator":
        return _pyglass.ByteList_rend(self)

    def clear(self) -> "void":
        return _pyglass.ByteList_clear(self)

    def get_allocator(self) -> "std::vector< unsigned char >::allocator_type":
        return _pyglass.ByteList_get_allocator(self)

    def pop_back(self) -> "void":
        return _pyglass.ByteList_pop_back(self)

    def erase(self, *args) -> "std::vector< unsigned char >::iterator":
        return _pyglass.ByteList_erase(self, *args)

    def __init__(self, *args):
        _pyglass.ByteList_swiginit(self, _pyglass.new_ByteList(*args))

    def push_back(self, x: "std::vector< unsigned char >::value_type const &") -> "void":
        return _pyglass.ByteList_push_back(self, x)

    def front(self) -> "std::vector< unsigned char >::value_type const &":
        return _pyglass.ByteList_front(self)

    def back(self) -> "std::vector< unsigned char >::value_type const &":
        return _pyglass.ByteList_back(self)

    def assign(self, n: "std::vector< unsigned char >::size_type", x: "std::vector< unsigned char >::value_type const &") -> "void":
        return _pyglass.ByteList_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _pyglass.ByteList_resize(self, *args)

    def insert(self, *args) -> "void":
        return _pyglass.ByteList_insert(self, *args)

    def reserve(self, n: "std::vector< unsigned char >::size_type") -> "void":
        return _pyglass.ByteList_reserve(self, n)

    def capacity(self) -> "std::vector< unsigned char >::size_type":
        return _pyglass.ByteList_capacity(self)
    __swig_destroy__ = _pyglass.delete_ByteList

# Register ByteList in _pyglass:
_pyglass.ByteList_swigregister(ByteList)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.StringList___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.StringList___bool__(self)

    def __len__(self) -> "std::vector< std::string >::size_type":
        return _pyglass.StringList___len__(self)

    def __getslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "std::vector< std::string,std::allocator< std::string > > *":
        return _pyglass.StringList___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _pyglass.StringList___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "void":
        return _pyglass.StringList___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _pyglass.StringList___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::string >::value_type const &":
        return _pyglass.StringList___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _pyglass.StringList___setitem__(self, *args)

    def pop(self) -> "std::vector< std::string >::value_type":
        return _pyglass.StringList_pop(self)

    def append(self, x: "std::vector< std::string >::value_type const &") -> "void":
        return _pyglass.StringList_append(self, x)

    def empty(self) -> "bool":
        return _pyglass.StringList_empty(self)

    def size(self) -> "std::vector< std::string >::size_type":
        return _pyglass.StringList_size(self)

    def swap(self, v: "StringList") -> "void":
        return _pyglass.StringList_swap(self, v)

    def begin(self) -> "std::vector< std::string >::iterator":
        return _pyglass.StringList_begin(self)

    def end(self) -> "std::vector< std::string >::iterator":
        return _pyglass.StringList_end(self)

    def rbegin(self) -> "std::vector< std::string >::reverse_iterator":
        return _pyglass.StringList_rbegin(self)

    def rend(self) -> "std::vector< std::string >::reverse_iterator":
        return _pyglass.StringList_rend(self)

    def clear(self) -> "void":
        return _pyglass.StringList_clear(self)

    def get_allocator(self) -> "std::vector< std::string >::allocator_type":
        return _pyglass.StringList_get_allocator(self)

    def pop_back(self) -> "void":
        return _pyglass.StringList_pop_back(self)

    def erase(self, *args) -> "std::vector< std::string >::iterator":
        return _pyglass.StringList_erase(self, *args)

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

    def push_back(self, x: "std::vector< std::string >::value_type const &") -> "void":
        return _pyglass.StringList_push_back(self, x)

    def front(self) -> "std::vector< std::string >::value_type const &":
        return _pyglass.StringList_front(self)

    def back(self) -> "std::vector< std::string >::value_type const &":
        return _pyglass.StringList_back(self)

    def assign(self, n: "std::vector< std::string >::size_type", x: "std::vector< std::string >::value_type const &") -> "void":
        return _pyglass.StringList_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _pyglass.StringList_resize(self, *args)

    def insert(self, *args) -> "void":
        return _pyglass.StringList_insert(self, *args)

    def reserve(self, n: "std::vector< std::string >::size_type") -> "void":
        return _pyglass.StringList_reserve(self, n)

    def capacity(self) -> "std::vector< std::string >::size_type":
        return _pyglass.StringList_capacity(self)
    __swig_destroy__ = _pyglass.delete_StringList

# Register StringList in _pyglass:
_pyglass.StringList_swigregister(StringList)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.PathList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.PathList___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.PathList___bool__(self)

    def __len__(self) -> "std::vector< boost::filesystem::path >::size_type":
        return _pyglass.PathList___len__(self)

    def __getslice__(self, i: "std::vector< boost::filesystem::path >::difference_type", j: "std::vector< boost::filesystem::path >::difference_type") -> "std::vector< boost::filesystem::path,std::allocator< boost::filesystem::path > > *":
        return _pyglass.PathList___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _pyglass.PathList___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< boost::filesystem::path >::difference_type", j: "std::vector< boost::filesystem::path >::difference_type") -> "void":
        return _pyglass.PathList___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _pyglass.PathList___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< boost::filesystem::path >::value_type const &":
        return _pyglass.PathList___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _pyglass.PathList___setitem__(self, *args)

    def pop(self) -> "std::vector< boost::filesystem::path >::value_type":
        return _pyglass.PathList_pop(self)

    def append(self, x: "path") -> "void":
        return _pyglass.PathList_append(self, x)

    def empty(self) -> "bool":
        return _pyglass.PathList_empty(self)

    def size(self) -> "std::vector< boost::filesystem::path >::size_type":
        return _pyglass.PathList_size(self)

    def swap(self, v: "PathList") -> "void":
        return _pyglass.PathList_swap(self, v)

    def begin(self) -> "std::vector< boost::filesystem::path >::iterator":
        return _pyglass.PathList_begin(self)

    def end(self) -> "std::vector< boost::filesystem::path >::iterator":
        return _pyglass.PathList_end(self)

    def rbegin(self) -> "std::vector< boost::filesystem::path >::reverse_iterator":
        return _pyglass.PathList_rbegin(self)

    def rend(self) -> "std::vector< boost::filesystem::path >::reverse_iterator":
        return _pyglass.PathList_rend(self)

    def clear(self) -> "void":
        return _pyglass.PathList_clear(self)

    def get_allocator(self) -> "std::vector< boost::filesystem::path >::allocator_type":
        return _pyglass.PathList_get_allocator(self)

    def pop_back(self) -> "void":
        return _pyglass.PathList_pop_back(self)

    def erase(self, *args) -> "std::vector< boost::filesystem::path >::iterator":
        return _pyglass.PathList_erase(self, *args)

    def __init__(self, *args):
        _pyglass.PathList_swiginit(self, _pyglass.new_PathList(*args))

    def push_back(self, x: "path") -> "void":
        return _pyglass.PathList_push_back(self, x)

    def front(self) -> "std::vector< boost::filesystem::path >::value_type const &":
        return _pyglass.PathList_front(self)

    def back(self) -> "std::vector< boost::filesystem::path >::value_type const &":
        return _pyglass.PathList_back(self)

    def assign(self, n: "std::vector< boost::filesystem::path >::size_type", x: "path") -> "void":
        return _pyglass.PathList_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _pyglass.PathList_resize(self, *args)

    def insert(self, *args) -> "void":
        return _pyglass.PathList_insert(self, *args)

    def reserve(self, n: "std::vector< boost::filesystem::path >::size_type") -> "void":
        return _pyglass.PathList_reserve(self, n)

    def capacity(self) -> "std::vector< boost::filesystem::path >::size_type":
        return _pyglass.PathList_capacity(self)
    __swig_destroy__ = _pyglass.delete_PathList

# Register PathList in _pyglass:
_pyglass.PathList_swigregister(PathList)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.IntList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.IntList___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.IntList___bool__(self)

    def __len__(self) -> "std::vector< int >::size_type":
        return _pyglass.IntList___len__(self)

    def __getslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "std::vector< int,std::allocator< int > > *":
        return _pyglass.IntList___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _pyglass.IntList___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "void":
        return _pyglass.IntList___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _pyglass.IntList___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< int >::value_type const &":
        return _pyglass.IntList___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _pyglass.IntList___setitem__(self, *args)

    def pop(self) -> "std::vector< int >::value_type":
        return _pyglass.IntList_pop(self)

    def append(self, x: "std::vector< int >::value_type const &") -> "void":
        return _pyglass.IntList_append(self, x)

    def empty(self) -> "bool":
        return _pyglass.IntList_empty(self)

    def size(self) -> "std::vector< int >::size_type":
        return _pyglass.IntList_size(self)

    def swap(self, v: "IntList") -> "void":
        return _pyglass.IntList_swap(self, v)

    def begin(self) -> "std::vector< int >::iterator":
        return _pyglass.IntList_begin(self)

    def end(self) -> "std::vector< int >::iterator":
        return _pyglass.IntList_end(self)

    def rbegin(self) -> "std::vector< int >::reverse_iterator":
        return _pyglass.IntList_rbegin(self)

    def rend(self) -> "std::vector< int >::reverse_iterator":
        return _pyglass.IntList_rend(self)

    def clear(self) -> "void":
        return _pyglass.IntList_clear(self)

    def get_allocator(self) -> "std::vector< int >::allocator_type":
        return _pyglass.IntList_get_allocator(self)

    def pop_back(self) -> "void":
        return _pyglass.IntList_pop_back(self)

    def erase(self, *args) -> "std::vector< int >::iterator":
        return _pyglass.IntList_erase(self, *args)

    def __init__(self, *args):
        _pyglass.IntList_swiginit(self, _pyglass.new_IntList(*args))

    def push_back(self, x: "std::vector< int >::value_type const &") -> "void":
        return _pyglass.IntList_push_back(self, x)

    def front(self) -> "std::vector< int >::value_type const &":
        return _pyglass.IntList_front(self)

    def back(self) -> "std::vector< int >::value_type const &":
        return _pyglass.IntList_back(self)

    def assign(self, n: "std::vector< int >::size_type", x: "std::vector< int >::value_type const &") -> "void":
        return _pyglass.IntList_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _pyglass.IntList_resize(self, *args)

    def insert(self, *args) -> "void":
        return _pyglass.IntList_insert(self, *args)

    def reserve(self, n: "std::vector< int >::size_type") -> "void":
        return _pyglass.IntList_reserve(self, n)

    def capacity(self) -> "std::vector< int >::size_type":
        return _pyglass.IntList_capacity(self)
    __swig_destroy__ = _pyglass.delete_IntList

# Register IntList in _pyglass:
_pyglass.IntList_swigregister(IntList)

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

    def __init__(self, *args):
        _pyglass.IntPair_swiginit(self, _pyglass.new_IntPair(*args))
    first = property(_pyglass.IntPair_first_get, _pyglass.IntPair_first_set)
    second = property(_pyglass.IntPair_second_get, _pyglass.IntPair_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__ = _pyglass.delete_IntPair

# Register IntPair in _pyglass:
_pyglass.IntPair_swigregister(IntPair)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringIntMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.StringIntMap___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.StringIntMap___bool__(self)

    def __len__(self) -> "std::map< std::string,int >::size_type":
        return _pyglass.StringIntMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::map< std::string,int >::key_type const &") -> "std::map< std::string,int >::mapped_type const &":
        return _pyglass.StringIntMap___getitem__(self, key)

    def __delitem__(self, key: "std::map< std::string,int >::key_type const &") -> "void":
        return _pyglass.StringIntMap___delitem__(self, key)

    def has_key(self, key: "std::map< std::string,int >::key_type const &") -> "bool":
        return _pyglass.StringIntMap_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _pyglass.StringIntMap_keys(self)

    def values(self) -> "PyObject *":
        return _pyglass.StringIntMap_values(self)

    def items(self) -> "PyObject *":
        return _pyglass.StringIntMap_items(self)

    def __contains__(self, key: "std::map< std::string,int >::key_type const &") -> "bool":
        return _pyglass.StringIntMap___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringIntMap_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringIntMap_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _pyglass.StringIntMap___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _pyglass.StringIntMap_asdict(self)

    def __init__(self, *args):
        _pyglass.StringIntMap_swiginit(self, _pyglass.new_StringIntMap(*args))

    def empty(self) -> "bool":
        return _pyglass.StringIntMap_empty(self)

    def size(self) -> "std::map< std::string,int >::size_type":
        return _pyglass.StringIntMap_size(self)

    def swap(self, v: "StringIntMap") -> "void":
        return _pyglass.StringIntMap_swap(self, v)

    def begin(self) -> "std::map< std::string,int >::iterator":
        return _pyglass.StringIntMap_begin(self)

    def end(self) -> "std::map< std::string,int >::iterator":
        return _pyglass.StringIntMap_end(self)

    def rbegin(self) -> "std::map< std::string,int >::reverse_iterator":
        return _pyglass.StringIntMap_rbegin(self)

    def rend(self) -> "std::map< std::string,int >::reverse_iterator":
        return _pyglass.StringIntMap_rend(self)

    def clear(self) -> "void":
        return _pyglass.StringIntMap_clear(self)

    def get_allocator(self) -> "std::map< std::string,int >::allocator_type":
        return _pyglass.StringIntMap_get_allocator(self)

    def count(self, x: "std::map< std::string,int >::key_type const &") -> "std::map< std::string,int >::size_type":
        return _pyglass.StringIntMap_count(self, x)

    def erase(self, *args) -> "void":
        return _pyglass.StringIntMap_erase(self, *args)

    def find(self, x: "std::map< std::string,int >::key_type const &") -> "std::map< std::string,int >::iterator":
        return _pyglass.StringIntMap_find(self, x)

    def lower_bound(self, x: "std::map< std::string,int >::key_type const &") -> "std::map< std::string,int >::iterator":
        return _pyglass.StringIntMap_lower_bound(self, x)

    def upper_bound(self, x: "std::map< std::string,int >::key_type const &") -> "std::map< std::string,int >::iterator":
        return _pyglass.StringIntMap_upper_bound(self, x)
    __swig_destroy__ = _pyglass.delete_StringIntMap

# Register StringIntMap in _pyglass:
_pyglass.StringIntMap_swigregister(StringIntMap)

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

    def iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringIntPairMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _pyglass.StringIntPairMap___nonzero__(self)

    def __bool__(self) -> "bool":
        return _pyglass.StringIntPairMap___bool__(self)

    def __len__(self) -> "std::map< std::string,std::pair< int,int > >::size_type":
        return _pyglass.StringIntPairMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "std::map< std::string,std::pair< int,int > >::mapped_type const &":
        return _pyglass.StringIntPairMap___getitem__(self, key)

    def __delitem__(self, key: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "void":
        return _pyglass.StringIntPairMap___delitem__(self, key)

    def has_key(self, key: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "bool":
        return _pyglass.StringIntPairMap_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _pyglass.StringIntPairMap_keys(self)

    def values(self) -> "PyObject *":
        return _pyglass.StringIntPairMap_values(self)

    def items(self) -> "PyObject *":
        return _pyglass.StringIntPairMap_items(self)

    def __contains__(self, key: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "bool":
        return _pyglass.StringIntPairMap___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringIntPairMap_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _pyglass.StringIntPairMap_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _pyglass.StringIntPairMap___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _pyglass.StringIntPairMap_asdict(self)

    def __init__(self, *args):
        _pyglass.StringIntPairMap_swiginit(self, _pyglass.new_StringIntPairMap(*args))

    def empty(self) -> "bool":
        return _pyglass.StringIntPairMap_empty(self)

    def size(self) -> "std::map< std::string,std::pair< int,int > >::size_type":
        return _pyglass.StringIntPairMap_size(self)

    def swap(self, v: "StringIntPairMap") -> "void":
        return _pyglass.StringIntPairMap_swap(self, v)

    def begin(self) -> "std::map< std::string,std::pair< int,int > >::iterator":
        return _pyglass.StringIntPairMap_begin(self)

    def end(self) -> "std::map< std::string,std::pair< int,int > >::iterator":
        return _pyglass.StringIntPairMap_end(self)

    def rbegin(self) -> "std::map< std::string,std::pair< int,int > >::reverse_iterator":
        return _pyglass.StringIntPairMap_rbegin(self)

    def rend(self) -> "std::map< std::string,std::pair< int,int > >::reverse_iterator":
        return _pyglass.StringIntPairMap_rend(self)

    def clear(self) -> "void":
        return _pyglass.StringIntPairMap_clear(self)

    def get_allocator(self) -> "std::map< std::string,std::pair< int,int > >::allocator_type":
        return _pyglass.StringIntPairMap_get_allocator(self)

    def count(self, x: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "std::map< std::string,std::pair< int,int > >::size_type":
        return _pyglass.StringIntPairMap_count(self, x)

    def erase(self, *args) -> "void":
        return _pyglass.StringIntPairMap_erase(self, *args)

    def find(self, x: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "std::map< std::string,std::pair< int,int > >::iterator":
        return _pyglass.StringIntPairMap_find(self, x)

    def lower_bound(self, x: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "std::map< std::string,std::pair< int,int > >::iterator":
        return _pyglass.StringIntPairMap_lower_bound(self, x)

    def upper_bound(self, x: "std::map< std::string,std::pair< int,int > >::key_type const &") -> "std::map< std::string,std::pair< int,int > >::iterator":
        return _pyglass.StringIntPairMap_upper_bound(self, x)
    __swig_destroy__ = _pyglass.delete_StringIntPairMap

# Register StringIntPairMap in _pyglass:
_pyglass.StringIntPairMap_swigregister(StringIntPairMap)

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

    def __init__(self):
        _pyglass.IReaderPtr_swiginit(self, _pyglass.new_IReaderPtr())
    __swig_destroy__ = _pyglass.delete_IReaderPtr

# Register IReaderPtr in _pyglass:
_pyglass.IReaderPtr_swigregister(IReaderPtr)



