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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if name == "thisown":
        return self.this.own(value)
    if name == "this":
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if not static:
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if name == "thisown":
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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



def __new_decorator(factory_func, original_new):
    @staticmethod
    def __new(cls, *args, **kwargs):
# FIXME: while this workaround solves the immediate issue with the set of classes we currently have,
# it will fail for classes that use a factory function but need no parameters at all, in which case
# the factory function will never be invoked, only the original __new__ function.
        if args or kwargs:
            return factory_func(*args, **kwargs)
        return original_new(cls)
    return __new

def __managed_init(self, *args, **kwargs):
    self._args = args
    self._kwargs = kwargs

class MemoryResource(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__ = _py3dna.delete_MemoryResource

    def allocate(self, size, alignment):
        return _py3dna.MemoryResource_allocate(self, size, alignment)

    def deallocate(self, ptr, size, alignment):
        return _py3dna.MemoryResource_deallocate(self, ptr, size, alignment)

# Register MemoryResource in _py3dna:
_py3dna.MemoryResource_swigregister(MemoryResource)

class AlignedMemoryResource(MemoryResource):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def allocate(self, size, alignment):
        return _py3dna.AlignedMemoryResource_allocate(self, size, alignment)

    def deallocate(self, ptr, size, alignment):
        return _py3dna.AlignedMemoryResource_deallocate(self, ptr, size, alignment)

    def __init__(self):
        _py3dna.AlignedMemoryResource_swiginit(self, _py3dna.new_AlignedMemoryResource())
    __swig_destroy__ = _py3dna.delete_AlignedMemoryResource

# Register AlignedMemoryResource in _py3dna:
_py3dna.AlignedMemoryResource_swigregister(AlignedMemoryResource)

class ArenaMemoryResource(MemoryResource):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _py3dna.delete_ArenaMemoryResource

    def __init__(self, *args):
        _py3dna.ArenaMemoryResource_swiginit(self, _py3dna.new_ArenaMemoryResource(*args))

    def allocate(self, size, alignment):
        return _py3dna.ArenaMemoryResource_allocate(self, size, alignment)

    def deallocate(self, ptr, size, alignment):
        return _py3dna.ArenaMemoryResource_deallocate(self, ptr, size, alignment)

    def getUpstreamMemoryResource(self):
        return _py3dna.ArenaMemoryResource_getUpstreamMemoryResource(self)

# Register ArenaMemoryResource in _py3dna:
_py3dna.ArenaMemoryResource_swigregister(ArenaMemoryResource)

class DefaultMemoryResource(MemoryResource):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def allocate(self, size, alignment):
        return _py3dna.DefaultMemoryResource_allocate(self, size, alignment)

    def deallocate(self, ptr, size, alignment):
        return _py3dna.DefaultMemoryResource_deallocate(self, ptr, size, alignment)

    def __init__(self):
        _py3dna.DefaultMemoryResource_swiginit(self, _py3dna.new_DefaultMemoryResource())
    __swig_destroy__ = _py3dna.delete_DefaultMemoryResource

# Register DefaultMemoryResource in _py3dna:
_py3dna.DefaultMemoryResource_swigregister(DefaultMemoryResource)

class StatusCode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    code = property(_py3dna.StatusCode_code_get, _py3dna.StatusCode_code_set)
    message = property(_py3dna.StatusCode_message_get, _py3dna.StatusCode_message_set)

    def __init__(self):
        _py3dna.StatusCode_swiginit(self, _py3dna.new_StatusCode())
    __swig_destroy__ = _py3dna.delete_StatusCode

# Register StatusCode in _py3dna:
_py3dna.StatusCode_swigregister(StatusCode)

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

    @staticmethod
    def isOk():
        return _py3dna.Status_isOk()

    @staticmethod
    def get():
        return _py3dna.Status_get()

    @staticmethod
    def getHook():
        return _py3dna.Status_getHook()

    @staticmethod
    def setHook(hook):
        return _py3dna.Status_setHook(hook)

    def __init__(self):
        _py3dna.Status_swiginit(self, _py3dna.new_Status())
    __swig_destroy__ = _py3dna.delete_Status

# Register Status in _py3dna:
_py3dna.Status_swigregister(Status)

def Status_isOk():
    return _py3dna.Status_isOk()

def Status_get():
    return _py3dna.Status_get()

def Status_getHook():
    return _py3dna.Status_getHook()

def Status_setHook(hook):
    return _py3dna.Status_setHook(hook)

class Readable(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 read(self, *args):
        return _py3dna.Readable_read(self, *args)

# Register Readable in _py3dna:
_py3dna.Readable_swigregister(Readable)

class Writable(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 write(self, *args):
        return _py3dna.Writable_write(self, *args)

# Register Writable in _py3dna:
_py3dna.Writable_swigregister(Writable)

class Seekable(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 tell(self):
        return _py3dna.Seekable_tell(self)

    def seek(self, position):
        return _py3dna.Seekable_seek(self, position)

# Register Seekable in _py3dna:
_py3dna.Seekable_swigregister(Seekable)

class Openable(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 open(self):
        return _py3dna.Openable_open(self)

# Register Openable in _py3dna:
_py3dna.Openable_swigregister(Openable)

class Closeable(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 close(self):
        return _py3dna.Closeable_close(self)

# Register Closeable in _py3dna:
_py3dna.Closeable_swigregister(Closeable)

class Controllable(Openable, Closeable):
    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

# Register Controllable in _py3dna:
_py3dna.Controllable_swigregister(Controllable)

class Bounded(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 size(self):
        return _py3dna.Bounded_size(self)

# Register Bounded in _py3dna:
_py3dna.Bounded_swigregister(Bounded)

class Buffered(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 flush(self):
        return _py3dna.Buffered_flush(self)

# Register Buffered in _py3dna:
_py3dna.Buffered_swigregister(Buffered)

class Resizable(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 resize(self, size):
        return _py3dna.Resizable_resize(self, size)

# Register Resizable in _py3dna:
_py3dna.Resizable_swigregister(Resizable)

class BoundedIOStream(Controllable, Readable, Writable, Seekable, Bounded):
    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__ = _py3dna.delete_BoundedIOStream

# Register BoundedIOStream in _py3dna:
_py3dna.BoundedIOStream_swigregister(BoundedIOStream)
cvar = _py3dna.cvar
BoundedIOStream.OpenError = _py3dna.cvar.BoundedIOStream_OpenError
BoundedIOStream.ReadError = _py3dna.cvar.BoundedIOStream_ReadError
BoundedIOStream.WriteError = _py3dna.cvar.BoundedIOStream_WriteError
BoundedIOStream.AlreadyOpenError = _py3dna.cvar.BoundedIOStream_AlreadyOpenError
BoundedIOStream.SeekError = _py3dna.cvar.BoundedIOStream_SeekError

AccessMode_Read = _py3dna.AccessMode_Read
AccessMode_Write = _py3dna.AccessMode_Write
AccessMode_ReadWrite = _py3dna.AccessMode_ReadWrite
OpenMode_Binary = _py3dna.OpenMode_Binary
OpenMode_Text = _py3dna.OpenMode_Text
class FileStream(BoundedIOStream):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(path, accessMode, openMode, memRes=None):
        return _py3dna.FileStream_create(path, accessMode, openMode, memRes)

    @staticmethod
    def destroy(instance):
        return _py3dna.FileStream_destroy(instance)
    __swig_destroy__ = _py3dna.delete_FileStream

# Register FileStream in _py3dna:
_py3dna.FileStream_swigregister(FileStream)

def FileStream_create(path, accessMode, openMode, memRes=None):
    return _py3dna.FileStream_create(path, accessMode, openMode, memRes)

def FileStream_destroy(instance):
    return _py3dna.FileStream_destroy(instance)

class MemoryMappedFileStream(BoundedIOStream, Buffered, Resizable):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(path, accessMode, memRes=None):
        return _py3dna.MemoryMappedFileStream_create(path, accessMode, memRes)

    @staticmethod
    def destroy(instance):
        return _py3dna.MemoryMappedFileStream_destroy(instance)
    __swig_destroy__ = _py3dna.delete_MemoryMappedFileStream

# Register MemoryMappedFileStream in _py3dna:
_py3dna.MemoryMappedFileStream_swigregister(MemoryMappedFileStream)

def MemoryMappedFileStream_create(path, accessMode, memRes=None):
    return _py3dna.MemoryMappedFileStream_create(path, accessMode, memRes)

def MemoryMappedFileStream_destroy(instance):
    return _py3dna.MemoryMappedFileStream_destroy(instance)

class MemoryStream(BoundedIOStream):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(*args):
        return _py3dna.MemoryStream_create(*args)

    @staticmethod
    def destroy(instance):
        return _py3dna.MemoryStream_destroy(instance)
    __swig_destroy__ = _py3dna.delete_MemoryStream

# Register MemoryStream in _py3dna:
_py3dna.MemoryStream_swigregister(MemoryStream)

def MemoryStream_create(*args):
    return _py3dna.MemoryStream_create(*args)

def MemoryStream_destroy(instance):
    return _py3dna.MemoryStream_destroy(instance)


FileStream.__new__ = __new_decorator(FileStream_create, FileStream.__new__)
FileStream.__del__ = lambda instance: FileStream_destroy(instance)
FileStream.__init__ = __managed_init
del FileStream.create
del FileStream.destroy


MemoryMappedFileStream.__new__ = __new_decorator(MemoryMappedFileStream_create, MemoryMappedFileStream.__new__)
MemoryMappedFileStream.__del__ = lambda instance: MemoryMappedFileStream_destroy(instance)
MemoryMappedFileStream.__init__ = __managed_init
del MemoryMappedFileStream.create
del MemoryMappedFileStream.destroy


MemoryStream.__new__ = __new_decorator(MemoryStream_create, MemoryStream.__new__)
MemoryStream.__del__ = lambda instance: MemoryStream_destroy(instance)
MemoryStream.__init__ = __managed_init
del MemoryStream.create
del MemoryStream.destroy


FileStream.AccessMode_Read = AccessMode_Read
FileStream.AccessMode_Write = AccessMode_Write
FileStream.AccessMode_ReadWrite = AccessMode_ReadWrite

FileStream.OpenMode_Binary = OpenMode_Binary
FileStream.OpenMode_Text = OpenMode_Text

MemoryMappedFileStream.AccessMode_Read = AccessMode_Read
MemoryMappedFileStream.AccessMode_Write = AccessMode_Write
MemoryMappedFileStream.AccessMode_ReadWrite = AccessMode_ReadWrite

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

    def c_str(self):
        return _py3dna.StringView_c_str(self)

    def __ref__(self):
        return _py3dna.StringView___ref__(self)

    def __init__(self):
        _py3dna.StringView_swiginit(self, _py3dna.new_StringView())
    __swig_destroy__ = _py3dna.delete_StringView

# Register StringView in _py3dna:
_py3dna.StringView_swigregister(StringView)


def __add__(*args):
    return _py3dna.__add__(*args)

def __sub__(*args):
    return _py3dna.__sub__(*args)

def __mul__(*args):
    return _py3dna.__mul__(*args)

def __truediv__(*args):
    return _py3dna.__truediv__(*args)

def __eq__(*args):
    return _py3dna.__eq__(*args)

def __ne__(*args):
    return _py3dna.__ne__(*args)
DataLayer_Descriptor = _py3dna.DataLayer_Descriptor
DataLayer_Definition = _py3dna.DataLayer_Definition
DataLayer_Behavior = _py3dna.DataLayer_Behavior
DataLayer_Geometry = _py3dna.DataLayer_Geometry
DataLayer_GeometryWithoutBlendShapes = _py3dna.DataLayer_GeometryWithoutBlendShapes
DataLayer_AllWithoutBlendShapes = _py3dna.DataLayer_AllWithoutBlendShapes
DataLayer_All = _py3dna.DataLayer_All
Archetype_asian = _py3dna.Archetype_asian
Archetype_black = _py3dna.Archetype_black
Archetype_caucasian = _py3dna.Archetype_caucasian
Archetype_hispanic = _py3dna.Archetype_hispanic
Archetype_alien = _py3dna.Archetype_alien
Archetype_other = _py3dna.Archetype_other
Gender_male = _py3dna.Gender_male
Gender_female = _py3dna.Gender_female
Gender_other = _py3dna.Gender_other
TranslationUnit_cm = _py3dna.TranslationUnit_cm
TranslationUnit_m = _py3dna.TranslationUnit_m
RotationUnit_degrees = _py3dna.RotationUnit_degrees
RotationUnit_radians = _py3dna.RotationUnit_radians
Direction_left = _py3dna.Direction_left
Direction_right = _py3dna.Direction_right
Direction_up = _py3dna.Direction_up
Direction_down = _py3dna.Direction_down
Direction_front = _py3dna.Direction_front
Direction_back = _py3dna.Direction_back
class CoordinateSystem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    xAxis = property(_py3dna.CoordinateSystem_xAxis_get, _py3dna.CoordinateSystem_xAxis_set)
    yAxis = property(_py3dna.CoordinateSystem_yAxis_get, _py3dna.CoordinateSystem_yAxis_set)
    zAxis = property(_py3dna.CoordinateSystem_zAxis_get, _py3dna.CoordinateSystem_zAxis_set)

    def __init__(self):
        _py3dna.CoordinateSystem_swiginit(self, _py3dna.new_CoordinateSystem())
    __swig_destroy__ = _py3dna.delete_CoordinateSystem

# Register CoordinateSystem in _py3dna:
_py3dna.CoordinateSystem_swigregister(CoordinateSystem)

class DescriptorReader(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 getName(self):
        return _py3dna.DescriptorReader_getName(self)

    def getArchetype(self):
        return _py3dna.DescriptorReader_getArchetype(self)

    def getGender(self):
        return _py3dna.DescriptorReader_getGender(self)

    def getAge(self):
        return _py3dna.DescriptorReader_getAge(self)

    def getMetaDataCount(self):
        return _py3dna.DescriptorReader_getMetaDataCount(self)

    def getMetaDataKey(self, index):
        return _py3dna.DescriptorReader_getMetaDataKey(self, index)

    def getMetaDataValue(self, key):
        return _py3dna.DescriptorReader_getMetaDataValue(self, key)

    def getTranslationUnit(self):
        return _py3dna.DescriptorReader_getTranslationUnit(self)

    def getRotationUnit(self):
        return _py3dna.DescriptorReader_getRotationUnit(self)

    def getCoordinateSystem(self):
        return _py3dna.DescriptorReader_getCoordinateSystem(self)

    def getLODCount(self):
        return _py3dna.DescriptorReader_getLODCount(self)

    def getDBMaxLOD(self):
        return _py3dna.DescriptorReader_getDBMaxLOD(self)

    def getDBComplexity(self):
        return _py3dna.DescriptorReader_getDBComplexity(self)

    def getDBName(self):
        return _py3dna.DescriptorReader_getDBName(self)

# Register DescriptorReader in _py3dna:
_py3dna.DescriptorReader_swigregister(DescriptorReader)

class MeshBlendShapeChannelMapping(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    meshIndex = property(_py3dna.MeshBlendShapeChannelMapping_meshIndex_get, _py3dna.MeshBlendShapeChannelMapping_meshIndex_set)
    blendShapeChannelIndex = property(_py3dna.MeshBlendShapeChannelMapping_blendShapeChannelIndex_get, _py3dna.MeshBlendShapeChannelMapping_blendShapeChannelIndex_set)

    def __init__(self):
        _py3dna.MeshBlendShapeChannelMapping_swiginit(self, _py3dna.new_MeshBlendShapeChannelMapping())
    __swig_destroy__ = _py3dna.delete_MeshBlendShapeChannelMapping

# Register MeshBlendShapeChannelMapping in _py3dna:
_py3dna.MeshBlendShapeChannelMapping_swigregister(MeshBlendShapeChannelMapping)

class DefinitionReader(DescriptorReader):
    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 getGUIControlCount(self):
        return _py3dna.DefinitionReader_getGUIControlCount(self)

    def getGUIControlName(self, index):
        return _py3dna.DefinitionReader_getGUIControlName(self, index)

    def getRawControlCount(self):
        return _py3dna.DefinitionReader_getRawControlCount(self)

    def getRawControlName(self, index):
        return _py3dna.DefinitionReader_getRawControlName(self, index)

    def getJointCount(self):
        return _py3dna.DefinitionReader_getJointCount(self)

    def getJointName(self, index):
        return _py3dna.DefinitionReader_getJointName(self, index)

    def getJointIndexListCount(self):
        return _py3dna.DefinitionReader_getJointIndexListCount(self)

    def getJointIndicesForLOD(self, lod):
        return _py3dna.DefinitionReader_getJointIndicesForLOD(self, lod)

    def getJointParentIndex(self, index):
        return _py3dna.DefinitionReader_getJointParentIndex(self, index)

    def getBlendShapeChannelCount(self):
        return _py3dna.DefinitionReader_getBlendShapeChannelCount(self)

    def getBlendShapeChannelName(self, index):
        return _py3dna.DefinitionReader_getBlendShapeChannelName(self, index)

    def getBlendShapeChannelIndexListCount(self):
        return _py3dna.DefinitionReader_getBlendShapeChannelIndexListCount(self)

    def getBlendShapeChannelIndicesForLOD(self, lod):
        return _py3dna.DefinitionReader_getBlendShapeChannelIndicesForLOD(self, lod)

    def getAnimatedMapCount(self):
        return _py3dna.DefinitionReader_getAnimatedMapCount(self)

    def getAnimatedMapName(self, index):
        return _py3dna.DefinitionReader_getAnimatedMapName(self, index)

    def getAnimatedMapIndexListCount(self):
        return _py3dna.DefinitionReader_getAnimatedMapIndexListCount(self)

    def getAnimatedMapIndicesForLOD(self, lod):
        return _py3dna.DefinitionReader_getAnimatedMapIndicesForLOD(self, lod)

    def getMeshCount(self):
        return _py3dna.DefinitionReader_getMeshCount(self)

    def getMeshName(self, index):
        return _py3dna.DefinitionReader_getMeshName(self, index)

    def getMeshIndexListCount(self):
        return _py3dna.DefinitionReader_getMeshIndexListCount(self)

    def getMeshIndicesForLOD(self, lod):
        return _py3dna.DefinitionReader_getMeshIndicesForLOD(self, lod)

    def getMeshBlendShapeChannelMappingCount(self):
        return _py3dna.DefinitionReader_getMeshBlendShapeChannelMappingCount(self)

    def getMeshBlendShapeChannelMapping(self, index):
        return _py3dna.DefinitionReader_getMeshBlendShapeChannelMapping(self, index)

    def getMeshBlendShapeChannelMappingIndicesForLOD(self, lod):
        return _py3dna.DefinitionReader_getMeshBlendShapeChannelMappingIndicesForLOD(self, lod)

    def getNeutralJointTranslation(self, index):
        return _py3dna.DefinitionReader_getNeutralJointTranslation(self, index)

    def getNeutralJointTranslationXs(self):
        return _py3dna.DefinitionReader_getNeutralJointTranslationXs(self)

    def getNeutralJointTranslationYs(self):
        return _py3dna.DefinitionReader_getNeutralJointTranslationYs(self)

    def getNeutralJointTranslationZs(self):
        return _py3dna.DefinitionReader_getNeutralJointTranslationZs(self)

    def getNeutralJointRotation(self, index):
        return _py3dna.DefinitionReader_getNeutralJointRotation(self, index)

    def getNeutralJointRotationXs(self):
        return _py3dna.DefinitionReader_getNeutralJointRotationXs(self)

    def getNeutralJointRotationYs(self):
        return _py3dna.DefinitionReader_getNeutralJointRotationYs(self)

    def getNeutralJointRotationZs(self):
        return _py3dna.DefinitionReader_getNeutralJointRotationZs(self)

# Register DefinitionReader in _py3dna:
_py3dna.DefinitionReader_swigregister(DefinitionReader)

class BehaviorReader(DefinitionReader):
    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 getGUIToRawInputIndices(self):
        return _py3dna.BehaviorReader_getGUIToRawInputIndices(self)

    def getGUIToRawOutputIndices(self):
        return _py3dna.BehaviorReader_getGUIToRawOutputIndices(self)

    def getGUIToRawFromValues(self):
        return _py3dna.BehaviorReader_getGUIToRawFromValues(self)

    def getGUIToRawToValues(self):
        return _py3dna.BehaviorReader_getGUIToRawToValues(self)

    def getGUIToRawSlopeValues(self):
        return _py3dna.BehaviorReader_getGUIToRawSlopeValues(self)

    def getGUIToRawCutValues(self):
        return _py3dna.BehaviorReader_getGUIToRawCutValues(self)

    def getPSDCount(self):
        return _py3dna.BehaviorReader_getPSDCount(self)

    def getPSDRowIndices(self):
        return _py3dna.BehaviorReader_getPSDRowIndices(self)

    def getPSDColumnIndices(self):
        return _py3dna.BehaviorReader_getPSDColumnIndices(self)

    def getPSDValues(self):
        return _py3dna.BehaviorReader_getPSDValues(self)

    def getJointRowCount(self):
        return _py3dna.BehaviorReader_getJointRowCount(self)

    def getJointColumnCount(self):
        return _py3dna.BehaviorReader_getJointColumnCount(self)

    def getJointVariableAttributeIndices(self, lod):
        return _py3dna.BehaviorReader_getJointVariableAttributeIndices(self, lod)

    def getJointGroupCount(self):
        return _py3dna.BehaviorReader_getJointGroupCount(self)

    def getJointGroupLODs(self, jointGroupIndex):
        return _py3dna.BehaviorReader_getJointGroupLODs(self, jointGroupIndex)

    def getJointGroupInputIndices(self, jointGroupIndex):
        return _py3dna.BehaviorReader_getJointGroupInputIndices(self, jointGroupIndex)

    def getJointGroupOutputIndices(self, jointGroupIndex):
        return _py3dna.BehaviorReader_getJointGroupOutputIndices(self, jointGroupIndex)

    def getJointGroupValues(self, jointGroupIndex):
        return _py3dna.BehaviorReader_getJointGroupValues(self, jointGroupIndex)

    def getJointGroupJointIndices(self, jointGroupIndex):
        return _py3dna.BehaviorReader_getJointGroupJointIndices(self, jointGroupIndex)

    def getBlendShapeChannelLODs(self):
        return _py3dna.BehaviorReader_getBlendShapeChannelLODs(self)

    def getBlendShapeChannelInputIndices(self):
        return _py3dna.BehaviorReader_getBlendShapeChannelInputIndices(self)

    def getBlendShapeChannelOutputIndices(self):
        return _py3dna.BehaviorReader_getBlendShapeChannelOutputIndices(self)

    def getAnimatedMapLODs(self):
        return _py3dna.BehaviorReader_getAnimatedMapLODs(self)

    def getAnimatedMapInputIndices(self):
        return _py3dna.BehaviorReader_getAnimatedMapInputIndices(self)

    def getAnimatedMapOutputIndices(self):
        return _py3dna.BehaviorReader_getAnimatedMapOutputIndices(self)

    def getAnimatedMapFromValues(self):
        return _py3dna.BehaviorReader_getAnimatedMapFromValues(self)

    def getAnimatedMapToValues(self):
        return _py3dna.BehaviorReader_getAnimatedMapToValues(self)

    def getAnimatedMapSlopeValues(self):
        return _py3dna.BehaviorReader_getAnimatedMapSlopeValues(self)

    def getAnimatedMapCutValues(self):
        return _py3dna.BehaviorReader_getAnimatedMapCutValues(self)

# Register BehaviorReader in _py3dna:
_py3dna.BehaviorReader_swigregister(BehaviorReader)

class GeometryReader(DefinitionReader):
    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 getVertexPositionCount(self, meshIndex):
        return _py3dna.GeometryReader_getVertexPositionCount(self, meshIndex)

    def getVertexPosition(self, meshIndex, vertexIndex):
        return _py3dna.GeometryReader_getVertexPosition(self, meshIndex, vertexIndex)

    def getVertexPositionXs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexPositionXs(self, meshIndex)

    def getVertexPositionYs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexPositionYs(self, meshIndex)

    def getVertexPositionZs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexPositionZs(self, meshIndex)

    def getVertexTextureCoordinateCount(self, meshIndex):
        return _py3dna.GeometryReader_getVertexTextureCoordinateCount(self, meshIndex)

    def getVertexTextureCoordinate(self, meshIndex, textureCoordinateIndex):
        return _py3dna.GeometryReader_getVertexTextureCoordinate(self, meshIndex, textureCoordinateIndex)

    def getVertexTextureCoordinateUs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexTextureCoordinateUs(self, meshIndex)

    def getVertexTextureCoordinateVs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexTextureCoordinateVs(self, meshIndex)

    def getVertexNormalCount(self, meshIndex):
        return _py3dna.GeometryReader_getVertexNormalCount(self, meshIndex)

    def getVertexNormal(self, meshIndex, normalIndex):
        return _py3dna.GeometryReader_getVertexNormal(self, meshIndex, normalIndex)

    def getVertexNormalXs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexNormalXs(self, meshIndex)

    def getVertexNormalYs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexNormalYs(self, meshIndex)

    def getVertexNormalZs(self, meshIndex):
        return _py3dna.GeometryReader_getVertexNormalZs(self, meshIndex)

    def getVertexLayoutCount(self, meshIndex):
        return _py3dna.GeometryReader_getVertexLayoutCount(self, meshIndex)

    def getVertexLayout(self, meshIndex, layoutIndex):
        return _py3dna.GeometryReader_getVertexLayout(self, meshIndex, layoutIndex)

    def getVertexLayoutPositionIndices(self, meshIndex):
        return _py3dna.GeometryReader_getVertexLayoutPositionIndices(self, meshIndex)

    def getVertexLayoutTextureCoordinateIndices(self, meshIndex):
        return _py3dna.GeometryReader_getVertexLayoutTextureCoordinateIndices(self, meshIndex)

    def getVertexLayoutNormalIndices(self, meshIndex):
        return _py3dna.GeometryReader_getVertexLayoutNormalIndices(self, meshIndex)

    def getFaceCount(self, meshIndex):
        return _py3dna.GeometryReader_getFaceCount(self, meshIndex)

    def getFaceVertexLayoutIndices(self, meshIndex, faceIndex):
        return _py3dna.GeometryReader_getFaceVertexLayoutIndices(self, meshIndex, faceIndex)

    def getMaximumInfluencePerVertex(self, meshIndex):
        return _py3dna.GeometryReader_getMaximumInfluencePerVertex(self, meshIndex)

    def getSkinWeightsCount(self, meshIndex):
        return _py3dna.GeometryReader_getSkinWeightsCount(self, meshIndex)

    def getSkinWeightsValues(self, meshIndex, vertexIndex):
        return _py3dna.GeometryReader_getSkinWeightsValues(self, meshIndex, vertexIndex)

    def getSkinWeightsJointIndices(self, meshIndex, vertexIndex):
        return _py3dna.GeometryReader_getSkinWeightsJointIndices(self, meshIndex, vertexIndex)

    def getBlendShapeTargetCount(self, meshIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetCount(self, meshIndex)

    def getBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex):
        return _py3dna.GeometryReader_getBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex)

    def getBlendShapeTargetDeltaCount(self, meshIndex, blendShapeTargetIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetDeltaCount(self, meshIndex, blendShapeTargetIndex)

    def getBlendShapeTargetDelta(self, meshIndex, blendShapeTargetIndex, deltaIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetDelta(self, meshIndex, blendShapeTargetIndex, deltaIndex)

    def getBlendShapeTargetDeltaXs(self, meshIndex, blendShapeTargetIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetDeltaXs(self, meshIndex, blendShapeTargetIndex)

    def getBlendShapeTargetDeltaYs(self, meshIndex, blendShapeTargetIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetDeltaYs(self, meshIndex, blendShapeTargetIndex)

    def getBlendShapeTargetDeltaZs(self, meshIndex, blendShapeTargetIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetDeltaZs(self, meshIndex, blendShapeTargetIndex)

    def getBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex):
        return _py3dna.GeometryReader_getBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex)

# Register GeometryReader in _py3dna:
_py3dna.GeometryReader_swigregister(GeometryReader)

class Reader(BehaviorReader, GeometryReader):
    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__ = _py3dna.delete_Reader

    def unload(self, layer):
        return _py3dna.Reader_unload(self, layer)

# Register Reader in _py3dna:
_py3dna.Reader_swigregister(Reader)

class StreamReader(Reader):
    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__ = _py3dna.delete_StreamReader

    def read(self):
        return _py3dna.StreamReader_read(self)

# Register StreamReader in _py3dna:
_py3dna.StreamReader_swigregister(StreamReader)
StreamReader.SignatureMismatchError = _py3dna.cvar.StreamReader_SignatureMismatchError
StreamReader.VersionMismatchError = _py3dna.cvar.StreamReader_VersionMismatchError
StreamReader.InvalidDataError = _py3dna.cvar.StreamReader_InvalidDataError

class BinaryStreamReader(StreamReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(*args):
        return _py3dna.BinaryStreamReader_create(*args)

    @staticmethod
    def destroy(instance):
        return _py3dna.BinaryStreamReader_destroy(instance)
    __swig_destroy__ = _py3dna.delete_BinaryStreamReader

# Register BinaryStreamReader in _py3dna:
_py3dna.BinaryStreamReader_swigregister(BinaryStreamReader)

def BinaryStreamReader_create(*args):
    return _py3dna.BinaryStreamReader_create(*args)

def BinaryStreamReader_destroy(instance):
    return _py3dna.BinaryStreamReader_destroy(instance)

class JSONStreamReader(StreamReader):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(stream, memRes=None):
        return _py3dna.JSONStreamReader_create(stream, memRes)

    @staticmethod
    def destroy(instance):
        return _py3dna.JSONStreamReader_destroy(instance)
    __swig_destroy__ = _py3dna.delete_JSONStreamReader

# Register JSONStreamReader in _py3dna:
_py3dna.JSONStreamReader_swigregister(JSONStreamReader)

def JSONStreamReader_create(stream, memRes=None):
    return _py3dna.JSONStreamReader_create(stream, memRes)

def JSONStreamReader_destroy(instance):
    return _py3dna.JSONStreamReader_destroy(instance)


BinaryStreamReader.__new__ = __new_decorator(BinaryStreamReader_create, BinaryStreamReader.__new__)
BinaryStreamReader.__del__ = lambda instance: BinaryStreamReader_destroy(instance)
BinaryStreamReader.__init__ = __managed_init
del BinaryStreamReader.create
del BinaryStreamReader.destroy


JSONStreamReader.__new__ = __new_decorator(JSONStreamReader_create, JSONStreamReader.__new__)
JSONStreamReader.__del__ = lambda instance: JSONStreamReader_destroy(instance)
JSONStreamReader.__init__ = __managed_init
del JSONStreamReader.create
del JSONStreamReader.destroy

class DescriptorWriter(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 setName(self, name):
        return _py3dna.DescriptorWriter_setName(self, name)

    def setArchetype(self, archetype):
        return _py3dna.DescriptorWriter_setArchetype(self, archetype)

    def setGender(self, gender):
        return _py3dna.DescriptorWriter_setGender(self, gender)

    def setAge(self, age):
        return _py3dna.DescriptorWriter_setAge(self, age)

    def clearMetaData(self):
        return _py3dna.DescriptorWriter_clearMetaData(self)

    def setMetaData(self, key, value):
        return _py3dna.DescriptorWriter_setMetaData(self, key, value)

    def setTranslationUnit(self, unit):
        return _py3dna.DescriptorWriter_setTranslationUnit(self, unit)

    def setRotationUnit(self, unit):
        return _py3dna.DescriptorWriter_setRotationUnit(self, unit)

    def setCoordinateSystem(self, system):
        return _py3dna.DescriptorWriter_setCoordinateSystem(self, system)

    def setLODCount(self, lodCount):
        return _py3dna.DescriptorWriter_setLODCount(self, lodCount)

    def setDBMaxLOD(self, lod):
        return _py3dna.DescriptorWriter_setDBMaxLOD(self, lod)

    def setDBComplexity(self, name):
        return _py3dna.DescriptorWriter_setDBComplexity(self, name)

    def setDBName(self, name):
        return _py3dna.DescriptorWriter_setDBName(self, name)

# Register DescriptorWriter in _py3dna:
_py3dna.DescriptorWriter_swigregister(DescriptorWriter)

class DefinitionWriter(DescriptorWriter):
    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 clearGUIControlNames(self):
        return _py3dna.DefinitionWriter_clearGUIControlNames(self)

    def setGUIControlName(self, index, name):
        return _py3dna.DefinitionWriter_setGUIControlName(self, index, name)

    def clearRawControlNames(self):
        return _py3dna.DefinitionWriter_clearRawControlNames(self)

    def setRawControlName(self, index, name):
        return _py3dna.DefinitionWriter_setRawControlName(self, index, name)

    def clearJointNames(self):
        return _py3dna.DefinitionWriter_clearJointNames(self)

    def setJointName(self, index, name):
        return _py3dna.DefinitionWriter_setJointName(self, index, name)

    def clearJointIndices(self):
        return _py3dna.DefinitionWriter_clearJointIndices(self)

    def setJointIndices(self, index, jointIndices):
        return _py3dna.DefinitionWriter_setJointIndices(self, index, jointIndices)

    def clearLODJointMappings(self):
        return _py3dna.DefinitionWriter_clearLODJointMappings(self)

    def setLODJointMapping(self, lod, index):
        return _py3dna.DefinitionWriter_setLODJointMapping(self, lod, index)

    def clearBlendShapeChannelNames(self):
        return _py3dna.DefinitionWriter_clearBlendShapeChannelNames(self)

    def setBlendShapeChannelName(self, index, name):
        return _py3dna.DefinitionWriter_setBlendShapeChannelName(self, index, name)

    def clearBlendShapeChannelIndices(self):
        return _py3dna.DefinitionWriter_clearBlendShapeChannelIndices(self)

    def setBlendShapeChannelIndices(self, index, blendShapeChannelIndices):
        return _py3dna.DefinitionWriter_setBlendShapeChannelIndices(self, index, blendShapeChannelIndices)

    def clearLODBlendShapeChannelMappings(self):
        return _py3dna.DefinitionWriter_clearLODBlendShapeChannelMappings(self)

    def setLODBlendShapeChannelMapping(self, lod, index):
        return _py3dna.DefinitionWriter_setLODBlendShapeChannelMapping(self, lod, index)

    def clearAnimatedMapNames(self):
        return _py3dna.DefinitionWriter_clearAnimatedMapNames(self)

    def setAnimatedMapName(self, index, name):
        return _py3dna.DefinitionWriter_setAnimatedMapName(self, index, name)

    def clearAnimatedMapIndices(self):
        return _py3dna.DefinitionWriter_clearAnimatedMapIndices(self)

    def setAnimatedMapIndices(self, index, animatedMapIndices):
        return _py3dna.DefinitionWriter_setAnimatedMapIndices(self, index, animatedMapIndices)

    def clearLODAnimatedMapMappings(self):
        return _py3dna.DefinitionWriter_clearLODAnimatedMapMappings(self)

    def setLODAnimatedMapMapping(self, lod, index):
        return _py3dna.DefinitionWriter_setLODAnimatedMapMapping(self, lod, index)

    def clearMeshNames(self):
        return _py3dna.DefinitionWriter_clearMeshNames(self)

    def setMeshName(self, index, name):
        return _py3dna.DefinitionWriter_setMeshName(self, index, name)

    def clearMeshIndices(self):
        return _py3dna.DefinitionWriter_clearMeshIndices(self)

    def setMeshIndices(self, index, meshIndices):
        return _py3dna.DefinitionWriter_setMeshIndices(self, index, meshIndices)

    def clearLODMeshMappings(self):
        return _py3dna.DefinitionWriter_clearLODMeshMappings(self)

    def setLODMeshMapping(self, lod, index):
        return _py3dna.DefinitionWriter_setLODMeshMapping(self, lod, index)

    def clearMeshBlendShapeChannelMappings(self):
        return _py3dna.DefinitionWriter_clearMeshBlendShapeChannelMappings(self)

    def setMeshBlendShapeChannelMapping(self, index, meshIndex, blendShapeChannelIndex):
        return _py3dna.DefinitionWriter_setMeshBlendShapeChannelMapping(self, index, meshIndex, blendShapeChannelIndex)

    def setJointHierarchy(self, jointIndices):
        return _py3dna.DefinitionWriter_setJointHierarchy(self, jointIndices)

    def setNeutralJointTranslations(self, translations):
        return _py3dna.DefinitionWriter_setNeutralJointTranslations(self, translations)

    def setNeutralJointRotations(self, rotations):
        return _py3dna.DefinitionWriter_setNeutralJointRotations(self, rotations)

# Register DefinitionWriter in _py3dna:
_py3dna.DefinitionWriter_swigregister(DefinitionWriter)

class BehaviorWriter(DefinitionWriter):
    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 setGUIToRawInputIndices(self, inputIndices):
        return _py3dna.BehaviorWriter_setGUIToRawInputIndices(self, inputIndices)

    def setGUIToRawOutputIndices(self, outputIndices):
        return _py3dna.BehaviorWriter_setGUIToRawOutputIndices(self, outputIndices)

    def setGUIToRawFromValues(self, fromValues):
        return _py3dna.BehaviorWriter_setGUIToRawFromValues(self, fromValues)

    def setGUIToRawToValues(self, toValues):
        return _py3dna.BehaviorWriter_setGUIToRawToValues(self, toValues)

    def setGUIToRawSlopeValues(self, slopeValues):
        return _py3dna.BehaviorWriter_setGUIToRawSlopeValues(self, slopeValues)

    def setGUIToRawCutValues(self, cutValues):
        return _py3dna.BehaviorWriter_setGUIToRawCutValues(self, cutValues)

    def setPSDCount(self, count):
        return _py3dna.BehaviorWriter_setPSDCount(self, count)

    def setPSDRowIndices(self, rowIndices):
        return _py3dna.BehaviorWriter_setPSDRowIndices(self, rowIndices)

    def setPSDColumnIndices(self, columnIndices):
        return _py3dna.BehaviorWriter_setPSDColumnIndices(self, columnIndices)

    def setPSDValues(self, weights):
        return _py3dna.BehaviorWriter_setPSDValues(self, weights)

    def setJointRowCount(self, rowCount):
        return _py3dna.BehaviorWriter_setJointRowCount(self, rowCount)

    def setJointColumnCount(self, columnCount):
        return _py3dna.BehaviorWriter_setJointColumnCount(self, columnCount)

    def clearJointGroups(self):
        return _py3dna.BehaviorWriter_clearJointGroups(self)

    def deleteJointGroup(self, jointGroupIndex):
        return _py3dna.BehaviorWriter_deleteJointGroup(self, jointGroupIndex)

    def setJointGroupLODs(self, jointGroupIndex, lods):
        return _py3dna.BehaviorWriter_setJointGroupLODs(self, jointGroupIndex, lods)

    def setJointGroupInputIndices(self, jointGroupIndex, inputIndices):
        return _py3dna.BehaviorWriter_setJointGroupInputIndices(self, jointGroupIndex, inputIndices)

    def setJointGroupOutputIndices(self, jointGroupIndex, outputIndices):
        return _py3dna.BehaviorWriter_setJointGroupOutputIndices(self, jointGroupIndex, outputIndices)

    def setJointGroupValues(self, jointGroupIndex, values):
        return _py3dna.BehaviorWriter_setJointGroupValues(self, jointGroupIndex, values)

    def setJointGroupJointIndices(self, jointGroupIndex, jointIndices):
        return _py3dna.BehaviorWriter_setJointGroupJointIndices(self, jointGroupIndex, jointIndices)

    def setBlendShapeChannelLODs(self, lods):
        return _py3dna.BehaviorWriter_setBlendShapeChannelLODs(self, lods)

    def setBlendShapeChannelInputIndices(self, inputIndices):
        return _py3dna.BehaviorWriter_setBlendShapeChannelInputIndices(self, inputIndices)

    def setBlendShapeChannelOutputIndices(self, outputIndices):
        return _py3dna.BehaviorWriter_setBlendShapeChannelOutputIndices(self, outputIndices)

    def setAnimatedMapLODs(self, lods):
        return _py3dna.BehaviorWriter_setAnimatedMapLODs(self, lods)

    def setAnimatedMapInputIndices(self, inputIndices):
        return _py3dna.BehaviorWriter_setAnimatedMapInputIndices(self, inputIndices)

    def setAnimatedMapOutputIndices(self, outputIndices):
        return _py3dna.BehaviorWriter_setAnimatedMapOutputIndices(self, outputIndices)

    def setAnimatedMapFromValues(self, fromValues):
        return _py3dna.BehaviorWriter_setAnimatedMapFromValues(self, fromValues)

    def setAnimatedMapToValues(self, toValues):
        return _py3dna.BehaviorWriter_setAnimatedMapToValues(self, toValues)

    def setAnimatedMapSlopeValues(self, slopeValues):
        return _py3dna.BehaviorWriter_setAnimatedMapSlopeValues(self, slopeValues)

    def setAnimatedMapCutValues(self, cutValues):
        return _py3dna.BehaviorWriter_setAnimatedMapCutValues(self, cutValues)

# Register BehaviorWriter in _py3dna:
_py3dna.BehaviorWriter_swigregister(BehaviorWriter)

class GeometryWriter(DefinitionWriter):
    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 clearMeshes(self):
        return _py3dna.GeometryWriter_clearMeshes(self)

    def deleteMesh(self, meshIndex):
        return _py3dna.GeometryWriter_deleteMesh(self, meshIndex)

    def setVertexPositions(self, meshIndex, positions):
        return _py3dna.GeometryWriter_setVertexPositions(self, meshIndex, positions)

    def setVertexTextureCoordinates(self, meshIndex, textureCoordinates):
        return _py3dna.GeometryWriter_setVertexTextureCoordinates(self, meshIndex, textureCoordinates)

    def setVertexNormals(self, meshIndex, normals):
        return _py3dna.GeometryWriter_setVertexNormals(self, meshIndex, normals)

    def setVertexLayouts(self, meshIndex, layouts):
        return _py3dna.GeometryWriter_setVertexLayouts(self, meshIndex, layouts)

    def clearFaceVertexLayoutIndices(self, meshIndex):
        return _py3dna.GeometryWriter_clearFaceVertexLayoutIndices(self, meshIndex)

    def setFaceVertexLayoutIndices(self, meshIndex, faceIndex, layoutIndices):
        return _py3dna.GeometryWriter_setFaceVertexLayoutIndices(self, meshIndex, faceIndex, layoutIndices)

    def setMaximumInfluencePerVertex(self, meshIndex, maxInfluenceCount):
        return _py3dna.GeometryWriter_setMaximumInfluencePerVertex(self, meshIndex, maxInfluenceCount)

    def clearSkinWeights(self, meshIndex):
        return _py3dna.GeometryWriter_clearSkinWeights(self, meshIndex)

    def setSkinWeightsValues(self, meshIndex, vertexIndex, weights):
        return _py3dna.GeometryWriter_setSkinWeightsValues(self, meshIndex, vertexIndex, weights)

    def setSkinWeightsJointIndices(self, meshIndex, vertexIndex, jointIndices):
        return _py3dna.GeometryWriter_setSkinWeightsJointIndices(self, meshIndex, vertexIndex, jointIndices)

    def clearBlendShapeTargets(self, meshIndex):
        return _py3dna.GeometryWriter_clearBlendShapeTargets(self, meshIndex)

    def setBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex, blendShapeChannelIndex):
        return _py3dna.GeometryWriter_setBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex, blendShapeChannelIndex)

    def setBlendShapeTargetDeltas(self, meshIndex, blendShapeTargetIndex, deltas):
        return _py3dna.GeometryWriter_setBlendShapeTargetDeltas(self, meshIndex, blendShapeTargetIndex, deltas)

    def setBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex, vertexIndices):
        return _py3dna.GeometryWriter_setBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex, vertexIndices)

# Register GeometryWriter in _py3dna:
_py3dna.GeometryWriter_swigregister(GeometryWriter)

class Writer(BehaviorWriter, GeometryWriter):
    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__ = _py3dna.delete_Writer

    def setFrom(self, *args):
        return _py3dna.Writer_setFrom(self, *args)

# Register Writer in _py3dna:
_py3dna.Writer_swigregister(Writer)

class StreamWriter(Writer):
    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__ = _py3dna.delete_StreamWriter

    def write(self):
        return _py3dna.StreamWriter_write(self)

# Register StreamWriter in _py3dna:
_py3dna.StreamWriter_swigregister(StreamWriter)

class BinaryStreamWriter(StreamWriter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(stream, memRes=None):
        return _py3dna.BinaryStreamWriter_create(stream, memRes)

    @staticmethod
    def destroy(instance):
        return _py3dna.BinaryStreamWriter_destroy(instance)
    __swig_destroy__ = _py3dna.delete_BinaryStreamWriter

# Register BinaryStreamWriter in _py3dna:
_py3dna.BinaryStreamWriter_swigregister(BinaryStreamWriter)

def BinaryStreamWriter_create(stream, memRes=None):
    return _py3dna.BinaryStreamWriter_create(stream, memRes)

def BinaryStreamWriter_destroy(instance):
    return _py3dna.BinaryStreamWriter_destroy(instance)

class JSONStreamWriter(StreamWriter):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    @staticmethod
    def create(stream, indentWidth=4, memRes=None):
        return _py3dna.JSONStreamWriter_create(stream, indentWidth, memRes)

    @staticmethod
    def destroy(instance):
        return _py3dna.JSONStreamWriter_destroy(instance)
    __swig_destroy__ = _py3dna.delete_JSONStreamWriter

# Register JSONStreamWriter in _py3dna:
_py3dna.JSONStreamWriter_swigregister(JSONStreamWriter)

def JSONStreamWriter_create(stream, indentWidth=4, memRes=None):
    return _py3dna.JSONStreamWriter_create(stream, indentWidth, memRes)

def JSONStreamWriter_destroy(instance):
    return _py3dna.JSONStreamWriter_destroy(instance)


BinaryStreamWriter.__new__ = __new_decorator(BinaryStreamWriter_create, BinaryStreamWriter.__new__)
BinaryStreamWriter.__del__ = lambda instance: BinaryStreamWriter_destroy(instance)
BinaryStreamWriter.__init__ = __managed_init
del BinaryStreamWriter.create
del BinaryStreamWriter.destroy


JSONStreamWriter.__new__ = __new_decorator(JSONStreamWriter_create, JSONStreamWriter.__new__)
JSONStreamWriter.__del__ = lambda instance: JSONStreamWriter_destroy(instance)
JSONStreamWriter.__init__ = __managed_init
del JSONStreamWriter.create
del JSONStreamWriter.destroy